heat-2014.1.5/0000775000567000056700000000000012540643116014027 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/0000775000567000056700000000000012540643116014750 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/0000775000567000056700000000000012540643116015335 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sync.py0000775000567000056700000000242112540642614016667 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # # 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. from __future__ import print_function import sys from heat.openstack.common import gettextutils gettextutils.install('heat') from oslo.config import cfg from heat.openstack.common import log as logging from heat.db import migration LOG = logging.getLogger(__name__) if __name__ == '__main__': print('*******************************************', file=sys.stderr) print('Deprecated: use heat-manage db_sync instead', file=sys.stderr) print('*******************************************', file=sys.stderr) cfg.CONF(project='heat', prog='heat-engine') try: migration.db_sync() except Exception as exc: print(str(exc), file=sys.stderr) sys.exit(1) heat-2014.1.5/heat/db/sqlalchemy/0000775000567000056700000000000012540643116017477 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sqlalchemy/types.py0000664000567000056700000000304412540642614021220 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. from json import dumps from json import loads from sqlalchemy import types from sqlalchemy.dialects import mysql class LongText(types.TypeDecorator): impl = types.Text def load_dialect_impl(self, dialect): if dialect.name == 'mysql': return dialect.type_descriptor(mysql.LONGTEXT()) else: return self.impl class Json(LongText): def process_bind_param(self, value, dialect): return dumps(value) def process_result_value(self, value, dialect): return loads(value) def associate_with(sqltype): # TODO(leizhang) When we removed sqlalchemy 0.7 dependence # we can import MutableDict directly and remove ./mutable.py try: from sqlalchemy.ext.mutable import MutableDict as sa_MutableDict sa_MutableDict.associate_with(Json) except ImportError: from heat.db.sqlalchemy.mutable import MutableDict MutableDict.associate_with(Json) associate_with(LongText) associate_with(Json) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/0000775000567000056700000000000012540643116022154 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/migrate.cfg0000664000567000056700000000231712540642611024267 0ustar jenkinsjenkins00000000000000[db_settings] # Used to identify which repository this database is versioned under. # You can use the name of your project. repository_id=heat # The name of the database table used to track the schema version. # This name shouldn't already be used by your project. # If this is changed once a database is under version control, you'll need to # change the table name in each database too. version_table=migrate_version # When committing a change script, Migrate will attempt to generate the # sql for all supported databases; normally, if one of them fails - probably # because you don't have that database installed - it is ignored and the # commit continues, perhaps ending successfully. # Databases in this list MUST compile successfully during a commit, or the # entire commit will fail. List the databases your application will actually # be using to ensure your updates to that database work properly. # This must be a list; example: ['postgres','sqlite'] required_dbs=[] # When creating new change scripts, Migrate will stamp the new script with # a version number. By default this is latest_version + 1. You can set this # to 'true' to tell Migrate to use the UTC timestamp instead. use_timestamp_numbering=False heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/0000775000567000056700000000000012540643116024024 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/030_remove_uuidutils.py0000664000567000056700000000250312540642614030366 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. import sqlalchemy import uuid def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.id.alter(type=sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) event = sqlalchemy.Table('event', meta, autoload=True) event.c.id.alter(type=sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) resource = sqlalchemy.Table('resource', meta, autoload=True) resource.c.id.alter(type=sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) def downgrade(migrate_engine): # since uuid.uuid4() works so no need to do downgrade pass heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/027_user_creds_trusts.py0000664000567000056700000000266412540642614030562 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) # keystone IDs are 32 characters long, but the keystone DB schema # specifies varchar(64) so align with that here, for the trust_id # we encrypt it, so align with the 255 chars allowed for password trustor_user_id = sqlalchemy.Column('trustor_user_id', sqlalchemy.String(length=64)) trust_id = sqlalchemy.Column('trust_id', sqlalchemy.String(length=255)) trustor_user_id.create(user_creds) trust_id.create(user_creds) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) user_creds.c.trustor_user_id.drop() user_creds.c.trust_id.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/040_software_deployment_no_signal_id.py0000664000567000056700000000220112540642614033555 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) software_deployment = sqlalchemy.Table( 'software_deployment', meta, autoload=True) software_deployment.c.signal_id.drop() def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) software_deployment = sqlalchemy.Table( 'software_deployment', meta, autoload=True) signal_id = sqlalchemy.Column('signal_id', sqlalchemy.String(1024)) signal_id.create(software_deployment) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/021_resource_data.py0000664000567000056700000000333312540642614027604 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine resource_data = sqlalchemy.Table( 'resource_data', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('key', sqlalchemy.String(255)), sqlalchemy.Column('value', sqlalchemy.Text), sqlalchemy.Column('redact', sqlalchemy.Boolean), sqlalchemy.Column('resource_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('resource.id'), nullable=False), mysql_engine='InnoDB', mysql_charset='utf8' ) sqlalchemy.Table('resource', meta, autoload=True) resource_data.create() def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine resource_data = sqlalchemy.Table('resource_data', meta, autoload=True) resource_data.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/042_software_deployment_domain_project.py0000664000567000056700000000226412540642614034140 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('software_deployment', meta, autoload=True) # Align with 64 character length used in keystone project table stack_user_project_id = sqlalchemy.Column('stack_user_project_id', sqlalchemy.String(length=64)) stack_user_project_id.create(stack) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('software_deployment', meta, autoload=True) stack.c.stack_user_project_id.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/022_stack_event_soft_delete.py0000664000567000056700000000373312540642614031654 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) sqlalchemy.Column('deleted_at', sqlalchemy.DateTime).create(stack) def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack = sqlalchemy.Table('stack', meta, autoload=True) event = sqlalchemy.Table('event', meta, autoload=True) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) raw_template = sqlalchemy.Table('raw_template', meta, autoload=True) # Remove soft deleted data not_deleted = None stmt = sqlalchemy.select([stack.c.id, stack.c.raw_template_id, stack.c.user_creds_id]).\ where(stack.c.deleted_at != not_deleted) deleted_stacks = migrate_engine.execute(stmt) for s in deleted_stacks: event_del = event.delete().where(event.c.stack_id == s[0]) migrate_engine.execute(event_del) stack_del = stack.delete().where(stack.c.id == s[0]) migrate_engine.execute(stack_del) raw_template_del = raw_template.delete().\ where(raw_template.c.id == s[1]) migrate_engine.execute(raw_template_del) user_creds_del = user_creds.delete().where(user_creds.c.id == s[2]) migrate_engine.execute(user_creds_del) stack.c.deleted_at.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/026_user_creds_drop_aws.py0000664000567000056700000000237312540642614031030 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) user_creds.c.aws_creds.drop() user_creds.c.aws_auth_url.drop() def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) aws_creds = sqlalchemy.Column('aws_creds', sqlalchemy.String(length=255)) aws_creds.create(user_creds) aws_auth_url = sqlalchemy.Column('aws_auth_url', sqlalchemy.String(length=255)) aws_auth_url.create(user_creds) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/039_user_creds_nullable.py0000664000567000056700000000202312540642614031004 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.user_creds_id.alter(nullable=True) def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.user_creds_id.alter(nullable=False) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/016_timeout_nullable.py0000664000567000056700000000173312540642614030336 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.timeout.alter(nullable=True) def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.timeout.alter(nullable=False) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py0000664000567000056700000000505712540642614033262 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. import copy from migrate.versioning import util as migrate_util from sqlalchemy.orm import sessionmaker from heat.openstack.common.gettextutils import _ from heat.db.sqlalchemy import models def upgrade(migrate_engine): Session = sessionmaker(bind=migrate_engine) session = Session() raw_templates = session.query(models.RawTemplate).all() CFN_TO_HOT_RESOURCE_ATTRS = {'Type': 'type', 'Properties': 'properties', 'Metadata': 'metadata', 'DependsOn': 'depends_on', 'DeletionPolicy': 'deletion_policy', 'UpdatePolicy': 'update_policy'} CFN_TO_HOT_OUTPUT_ATTRS = {'Description': 'description', 'Value': 'value'} def _translate(section, translate_map): changed = False for name, details in section.iteritems(): for old_key, new_key in translate_map.iteritems(): if old_key in details: details[new_key] = details[old_key] del details[old_key] changed = True return changed for raw_template in raw_templates: if 'heat_template_version' in raw_template.template: changed = False template = copy.deepcopy(raw_template.template) resources = template.get('resources', {}) if _translate(resources, CFN_TO_HOT_RESOURCE_ATTRS): changed = True outputs = template.get('outputs', {}) if _translate(outputs, CFN_TO_HOT_OUTPUT_ATTRS): changed = True if changed: raw_template.template = template session.commit() def downgrade(migrate_engine): migrate_util.log.warning(_('This version cannot be downgraded because ' 'it involves a data migration to the ' 'raw_template table.')) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/028_text_mysql_longtext.py0000664000567000056700000000355512540642614031136 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. import sqlalchemy from sqlalchemy.dialects import mysql from sqlalchemy import types as sqltypes def upgrade(migrate_engine): if migrate_engine.name != 'mysql': return meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.parameters.alter(type=mysql.LONGTEXT()) resource = sqlalchemy.Table('resource', meta, autoload=True) resource.c.rsrc_metadata.alter(type=mysql.LONGTEXT()) watch_rule = sqlalchemy.Table('watch_rule', meta, autoload=True) watch_rule.c.rule.alter(type=mysql.LONGTEXT()) watch_data = sqlalchemy.Table('watch_data', meta, autoload=True) watch_data.c.data.alter(type=mysql.LONGTEXT()) def downgrade(migrate_engine): if migrate_engine.name != 'mysql': return meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.parameters.alter(type=sqltypes.TEXT()) resource = sqlalchemy.Table('resource', meta, autoload=True) resource.c.rsrc_metadata.alter(type=sqltypes.TEXT()) watch_rule = sqlalchemy.Table('watch_rule', meta, autoload=True) watch_rule.c.rule.alter(type=sqltypes.TEXT()) watch_data = sqlalchemy.Table('watch_data', meta, autoload=True) watch_data.c.data.alter(type=sqltypes.TEXT()) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/023_raw_template_mysql_longtext.py0000664000567000056700000000227012540642614032622 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. import sqlalchemy from sqlalchemy.dialects import mysql from sqlalchemy import types as sqltypes def upgrade(migrate_engine): if migrate_engine.name != 'mysql': return meta = sqlalchemy.MetaData(bind=migrate_engine) raw_template = sqlalchemy.Table('raw_template', meta, autoload=True) raw_template.c.template.alter(type=mysql.LONGTEXT()) def downgrade(migrate_engine): if migrate_engine.name != 'mysql': return meta = sqlalchemy.MetaData(bind=migrate_engine) raw_template = sqlalchemy.Table('raw_template', meta, autoload=True) raw_template.c.template.alter(type=sqltypes.TEXT()) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/015_grizzly.py0000664000567000056700000001563512540642614026511 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine raw_template = sqlalchemy.Table( 'raw_template', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('template', sqlalchemy.Text), mysql_engine='InnoDB', mysql_charset='utf8' ) user_creds = sqlalchemy.Table( 'user_creds', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('username', sqlalchemy.String(255)), sqlalchemy.Column('password', sqlalchemy.String(255)), sqlalchemy.Column('service_user', sqlalchemy.String(255)), sqlalchemy.Column('service_password', sqlalchemy.String(255)), sqlalchemy.Column('tenant', sqlalchemy.String(1024)), sqlalchemy.Column('auth_url', sqlalchemy.Text), sqlalchemy.Column('aws_auth_url', sqlalchemy.Text), sqlalchemy.Column('tenant_id', sqlalchemy.String(256)), sqlalchemy.Column('aws_creds', sqlalchemy.Text), mysql_engine='InnoDB', mysql_charset='utf8' ) stack = sqlalchemy.Table( 'stack', meta, sqlalchemy.Column('id', sqlalchemy.String(36), primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('name', sqlalchemy.String(255)), sqlalchemy.Column('raw_template_id', sqlalchemy.Integer, sqlalchemy.ForeignKey('raw_template.id'), nullable=False), sqlalchemy.Column('user_creds_id', sqlalchemy.Integer, sqlalchemy.ForeignKey('user_creds.id'), nullable=False), sqlalchemy.Column('username', sqlalchemy.String(256)), sqlalchemy.Column('owner_id', sqlalchemy.String(36)), sqlalchemy.Column('status', sqlalchemy.String(255)), sqlalchemy.Column('status_reason', sqlalchemy.String(255)), sqlalchemy.Column('parameters', sqlalchemy.Text), sqlalchemy.Column('timeout', sqlalchemy.Integer, nullable=False), sqlalchemy.Column('tenant', sqlalchemy.String(256)), sqlalchemy.Column('disable_rollback', sqlalchemy.Boolean, nullable=False), mysql_engine='InnoDB', mysql_charset='utf8' ) resource = sqlalchemy.Table( 'resource', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('nova_instance', sqlalchemy.String(255)), sqlalchemy.Column('name', sqlalchemy.String(255)), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('state', sqlalchemy.String(255)), sqlalchemy.Column('state_description', sqlalchemy.String(255)), sqlalchemy.Column('stack_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), nullable=False), sqlalchemy.Column('rsrc_metadata', sqlalchemy.Text), mysql_engine='InnoDB', mysql_charset='utf8' ) event = sqlalchemy.Table( 'event', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('stack_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('name', sqlalchemy.String(255)), sqlalchemy.Column('logical_resource_id', sqlalchemy.String(255)), sqlalchemy.Column('physical_resource_id', sqlalchemy.String(255)), sqlalchemy.Column('resource_status_reason', sqlalchemy.String(255)), sqlalchemy.Column('resource_type', sqlalchemy.String(255)), sqlalchemy.Column('resource_properties', sqlalchemy.PickleType), mysql_engine='InnoDB', mysql_charset='utf8' ) watch_rule = sqlalchemy.Table( 'watch_rule', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('name', sqlalchemy.String(255)), sqlalchemy.Column('state', sqlalchemy.String(255)), sqlalchemy.Column('rule', sqlalchemy.Text), sqlalchemy.Column('last_evaluated', sqlalchemy.DateTime), sqlalchemy.Column('stack_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), nullable=False), mysql_engine='InnoDB', mysql_charset='utf8' ) watch_data = sqlalchemy.Table( 'watch_data', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('data', sqlalchemy.Text), sqlalchemy.Column('watch_rule_id', sqlalchemy.Integer, sqlalchemy.ForeignKey('watch_rule.id'), nullable=False), mysql_engine='InnoDB', mysql_charset='utf8' ) tables = ( raw_template, user_creds, stack, resource, event, watch_rule, watch_data, ) for index, table in enumerate(tables): try: table.create() except: # If an error occurs, drop all tables created so far to return # to the previously existing state. meta.drop_all(tables=tables[:index]) raise def downgrade(migrate_engine): raise NotImplementedError('Database downgrade not supported - ' 'would drop all tables') heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py0000664000567000056700000000300612540642614030316 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. import uuid import sqlalchemy from migrate.versioning import util as migrate_util from heat.openstack.common.gettextutils import _ def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) event = sqlalchemy.Table('event', meta, autoload=True) event.c.id.alter(type=sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) event = sqlalchemy.Table('event', meta, autoload=True) try: event.c.id.alter(type=sqlalchemy.Integer, primary_key=True) except: # NOTE(pafuent): since there is no way to downgrade just passing # The same is did in 018_resource_id_uuid.py migrate_util.log.warning(_('If you really want to downgrade to this ' 'version, you should drop all the records.' )) pass heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/032_decrypt_method.py0000664000567000056700000000232712540642614030002 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine for table in ('user_creds', 'resource_data'): table = sqlalchemy.Table(table, meta, autoload=True) method = sqlalchemy.Column('decrypt_method', sqlalchemy.String(length=64), default='heat_decrypt') method.create(table) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) for table in ('user_creds', 'resource_data'): table = sqlalchemy.Table(table, meta, autoload=True) table.c.decrypt_method.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/__init__.py0000664000567000056700000000000012540642611026122 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/038_software_config_json_config.py0000664000567000056700000000226612540642614032535 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. from heat.db.sqlalchemy.types import LongText from heat.db.sqlalchemy.types import Json import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) software_config = sqlalchemy.Table('software_config', meta, autoload=True) software_config.c.config.alter(type=Json) software_config.c.io.drop() def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) software_config = sqlalchemy.Table('software_config', meta, autoload=True) software_config.c.config.alter(type=LongText) io = sqlalchemy.Column('io', Json) io.create(software_config) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/034_raw_template_files.py0000664000567000056700000000210612540642614030633 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. import sqlalchemy from heat.db.sqlalchemy.types import Json def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine raw_template = sqlalchemy.Table('raw_template', meta, autoload=True) files = sqlalchemy.Column('files', Json, default={}) files.create(raw_template) def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine raw_template = sqlalchemy.Table('raw_template', meta, autoload=True) raw_template.c.files.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/017_event_state_status.py0000664000567000056700000000243212540642614030714 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine event = sqlalchemy.Table('event', meta, autoload=True) # Currently there is a 'name' column which really holds the # resource status, so rename it and add a separate action column # action is e.g "CREATE" and status is e.g "IN_PROGRESS" event.c.name.alter(name='resource_status') sqlalchemy.Column('resource_action', sqlalchemy.String(255)).create(event) def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine event = sqlalchemy.Table('event', meta, autoload=True) event.c.resource_status.alter(name='name') event.c.resource_action.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/020_stack_action.py0000664000567000056700000000211712540642614027424 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) # Align with action/status now used in the event/resource tables action = sqlalchemy.Column('action', sqlalchemy.String(length=255)) action.create(stack) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.action.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py0000664000567000056700000000425212540642614031171 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. import copy from migrate.versioning import util as migrate_util from sqlalchemy.orm import sessionmaker from heat.openstack.common.gettextutils import _ from heat.db.sqlalchemy import models from heat.engine.hot.parameters import HOTParamSchema def upgrade(migrate_engine): Session = sessionmaker(bind=migrate_engine) session = Session() raw_templates = session.query(models.RawTemplate).all() for raw_template in raw_templates: if ('heat_template_version' in raw_template.template and 'parameters' in raw_template.template): template = copy.deepcopy(raw_template.template) for parameter, schema in template['parameters'].iteritems(): changed = False def _commit_schema(parameter, schema): template['parameters'][parameter] = schema raw_template.template = template session.commit() if 'Type' in schema: schema['type'] = schema['Type'] del schema['Type'] changed = True if (schema.get('type') not in HOTParamSchema.TYPES and schema['type'].istitle()): schema['type'] = schema['type'].lower() changed = True if changed: _commit_schema(parameter, schema) def downgrade(migrate_engine): migrate_util.log.warning(_('This version cannot be downgraded because ' 'it involves a data migration to the ' 'raw_template table.')) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/035_event_uuid_to_id.py0000664000567000056700000001772312540642614030326 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. import uuid import itertools import sqlalchemy import migrate.changeset.constraint as constraint from heat.openstack.common import timeutils def upgrade(migrate_engine): if migrate_engine.name == 'sqlite': upgrade_sqlite(migrate_engine) return meta = sqlalchemy.MetaData(bind=migrate_engine) event_table = sqlalchemy.Table('event', meta, autoload=True) event_uuid = sqlalchemy.Column('uuid', sqlalchemy.String(length=36), default=lambda: str(uuid.uuid4)) event_table.create_column(event_uuid) if migrate_engine.name == 'postgresql': sequence = sqlalchemy.Sequence('evt') sqlalchemy.schema.CreateSequence(sequence, bind=migrate_engine).execute() event_id = sqlalchemy.Column('tmp_id', sqlalchemy.Integer, server_default=sqlalchemy.text( "nextval('evt')")) else: event_id = sqlalchemy.Column('tmp_id', sqlalchemy.Integer) event_table.create_column(event_id) fake_autoincrement = itertools.count(1) event_list = event_table.select().order_by( sqlalchemy.sql.expression.asc(event_table.c.created_at)).execute() for event in event_list: values = {'tmp_id': fake_autoincrement.next(), 'uuid': event.id} update = event_table.update().where( event_table.c.id == event.id).values(values) migrate_engine.execute(update) cons = constraint.UniqueConstraint('uuid', table=event_table) cons.create() event_table.c.id.drop() event_table.c.tmp_id.alter('id', sqlalchemy.Integer) cons = constraint.PrimaryKeyConstraint('tmp_id', table=event_table) cons.create() event_table.c.tmp_id.alter(sqlalchemy.Integer, autoincrement=True) def upgrade_sqlite(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) #(pafuent) Here it isn't recommended to import the table from the models, #because in future migrations the model could change and this migration #could fail. #I know it is ugly but it's the only way that I found to 'freeze' the model #state for this migration. stack_table = sqlalchemy.Table('stack', meta, autoload=True) event_table = sqlalchemy.Table( 'new_event', meta, sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True), sqlalchemy.Column('stack_id', sqlalchemy.String(36), sqlalchemy.ForeignKey(stack_table.c.id), nullable=False), sqlalchemy.Column('uuid', sqlalchemy.String(36), default=lambda: str(uuid.uuid4()), unique=True), sqlalchemy.Column('resource_action', sqlalchemy.String(255)), sqlalchemy.Column('resource_status', sqlalchemy.String(255)), sqlalchemy.Column('resource_name', sqlalchemy.String(255)), sqlalchemy.Column('physical_resource_id', sqlalchemy.String(255)), sqlalchemy.Column('resource_status_reason', sqlalchemy.String(255)), sqlalchemy.Column('resource_type', sqlalchemy.String(255)), sqlalchemy.Column('resource_properties', sqlalchemy.PickleType), sqlalchemy.Column('created_at', sqlalchemy.DateTime, default=timeutils.utcnow), sqlalchemy.Column('updated_at', sqlalchemy.DateTime, onupdate=timeutils.utcnow)) event_table.create() prev_event_table = sqlalchemy.Table('event', meta, autoload=True) event_list = list(prev_event_table.select().order_by( sqlalchemy.sql.expression.asc(prev_event_table.c.created_at)) .execute()) for event in event_list: values = { 'stack_id': event.stack_id, 'uuid': event.id, 'resource_action': event.resource_action, 'resource_status': event.resource_status, 'resource_name': event.resource_name, 'physical_resource_id': event.physical_resource_id, 'resource_status_reason': event.resource_status_reason, 'resource_type': event.resource_type, 'resource_properties': event.resource_properties} migrate_engine.execute(event_table.insert(values)) prev_event_table.drop() event_table.rename('event') def downgrade(migrate_engine): if migrate_engine.name == 'sqlite': downgrade_sqlite(migrate_engine) return meta = sqlalchemy.MetaData(bind=migrate_engine) event_table = sqlalchemy.Table('event', meta, autoload=True) event_id = sqlalchemy.Column('tmp_id', sqlalchemy.String(length=36), default=lambda: str(uuid.uuid4)) event_id.create(event_table) event_list = event_table.select().execute() for event in event_list: values = {'tmp_id': event.uuid} update = event_table.update().where( event_table.c.uuid == event.uuid).values(values) migrate_engine.execute(update) event_table.c.id.drop() event_table.c.uuid.drop() cons = constraint.PrimaryKeyConstraint('tmp_id', table=event_table) cons.create() event_table.c.tmp_id.alter('id', default=lambda: str(uuid.uuid4)) def downgrade_sqlite(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) #(pafuent) Here it isn't recommended to import the table from the models, #because in future migrations the model could change and this migration #could fail. #I know it is ugly but it's the only way that I found to 'freeze' the model #state for this migration. stack_table = sqlalchemy.Table('stack', meta, autoload=True) event_table = sqlalchemy.Table( 'new_event', meta, sqlalchemy.Column('id', sqlalchemy.String(36), default=lambda: str(uuid.uuid4())), sqlalchemy.Column('stack_id', sqlalchemy.String(36), sqlalchemy.ForeignKey(stack_table.c.id), nullable=False), sqlalchemy.Column('resource_action', sqlalchemy.String(255)), sqlalchemy.Column('resource_status', sqlalchemy.String(255)), sqlalchemy.Column('resource_name', sqlalchemy.String(255)), sqlalchemy.Column('physical_resource_id', sqlalchemy.String(255)), sqlalchemy.Column('resource_status_reason', sqlalchemy.String(255)), sqlalchemy.Column('resource_type', sqlalchemy.String(255)), sqlalchemy.Column('resource_properties', sqlalchemy.PickleType), sqlalchemy.Column('created_at', sqlalchemy.DateTime, default=timeutils.utcnow), sqlalchemy.Column('updated_at', sqlalchemy.DateTime, onupdate=timeutils.utcnow)) event_table.create() prev_event_table = sqlalchemy.Table('event', meta, autoload=True) event_list = prev_event_table.select().execute() for event in event_list: values = { 'id': event.uuid, 'stack_id': event.stack_id, 'resource_action': event.resource_action, 'resource_status': event.resource_status, 'resource_name': event.resource_name, 'physical_resource_id': event.physical_resource_id, 'resource_status_reason': event.resource_status_reason, 'resource_type': event.resource_type, 'resource_properties': event.resource_properties} migrate_engine.execute(event_table.insert(values)) prev_event_table.drop() event_table.rename('event') heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/019_resource_action_status.py0000664000567000056700000000252312540642614031562 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) resource = sqlalchemy.Table('resource', meta, autoload=True) # Align the current state/state_description with the # action/status now used in the event table action = sqlalchemy.Column('action', sqlalchemy.String(length=255)) action.create(resource) resource.c.state.alter(name='status') resource.c.state_description.alter(name='status_reason') def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) resource = sqlalchemy.Table('resource', meta, autoload=True) resource.c.action.drop() resource.c.status.alter(name='state') resource.c.status_reason.alter(name='state_description') heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/024_event_resource_name.py0000664000567000056700000000177612540642614031030 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine event = sqlalchemy.Table('event', meta, autoload=True) event.c.logical_resource_id.alter(name='resource_name') def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine event = sqlalchemy.Table('event', meta, autoload=True) event.c.resource_name.alter(name='logical_resource_id') heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/025_user_creds_drop_service.py0000664000567000056700000000243612540642614031675 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) user_creds.c.service_user.drop() user_creds.c.service_password.drop() def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) service_user = sqlalchemy.Column('service_user', sqlalchemy.String(length=255)) service_user.create(user_creds) service_password = sqlalchemy.Column('service_password', sqlalchemy.String(length=255)) service_password.create(user_creds) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/018_resource_id_uuid.py0000664000567000056700000000225112540642614030321 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. import uuid import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) resource = sqlalchemy.Table('resource', meta, autoload=True) resource.c.id.alter(sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) resource = sqlalchemy.Table('resource', meta, autoload=True) try: resource.c.id.alter(sqlalchemy.Integer, primary_key=True) except: #XXX: since there is no way to downgrade just passing pass heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/033_software_config.py0000664000567000056700000000627512540642614030156 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. import sqlalchemy from heat.db.sqlalchemy.types import Json from heat.db.sqlalchemy.types import LongText def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine software_config = sqlalchemy.Table( 'software_config', meta, sqlalchemy.Column('id', sqlalchemy.String(36), primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('name', sqlalchemy.String(255), nullable=True), sqlalchemy.Column('group', sqlalchemy.String(255)), sqlalchemy.Column('config', LongText), sqlalchemy.Column('io', Json), sqlalchemy.Column('tenant', sqlalchemy.String(64), nullable=False, index=True), mysql_engine='InnoDB', mysql_charset='utf8' ) software_config.create() software_deployment = sqlalchemy.Table( 'software_deployment', meta, sqlalchemy.Column('id', sqlalchemy.String(36), primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime, index=True), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('server_id', sqlalchemy.String(36), nullable=False, index=True), sqlalchemy.Column('config_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('software_config.id'), nullable=False), sqlalchemy.Column('input_values', Json), sqlalchemy.Column('output_values', Json), sqlalchemy.Column('signal_id', sqlalchemy.String(1024)), sqlalchemy.Column('action', sqlalchemy.String(255)), sqlalchemy.Column('status', sqlalchemy.String(255)), sqlalchemy.Column('status_reason', sqlalchemy.String(255)), sqlalchemy.Column('tenant', sqlalchemy.String(64), nullable=False, index=True), mysql_engine='InnoDB', mysql_charset='utf8' ) software_deployment.create() def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine software_deployment = sqlalchemy.Table( 'software_deployment', meta, autoload=True) software_deployment.drop() software_config = sqlalchemy.Table( 'software_config', meta, autoload=True) software_config.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/036_stack_domain_project.py0000664000567000056700000000223012540642614031147 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) # Align with 64 character length used in keystone project table stack_user_project_id = sqlalchemy.Column('stack_user_project_id', sqlalchemy.String(length=64)) stack_user_project_id.create(stack) def downgrade(migrate_engine): meta = sqlalchemy.MetaData(bind=migrate_engine) stack = sqlalchemy.Table('stack', meta, autoload=True) stack.c.stack_user_project_id.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py0000664000567000056700000000443212540642614032244 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. import copy import time from migrate.versioning import util as migrate_util from sqlalchemy.orm import sessionmaker from heat.openstack.common.gettextutils import _ from heat.db.sqlalchemy import models def upgrade(migrate_engine): Session = sessionmaker(bind=migrate_engine) session = Session() raw_templates = session.query(models.RawTemplate).all() # NOTE (sdake) 2014-04-24 is the date of the Icehouse release. It is # possible that folks could continue to make errors in their templates # right up until the release of Icehouse. For stacks with version dates # in the future, they remain unlistable. This is to prevent future # breakage when new versions come out patch_date = time.strptime('2014-04-24', '%Y-%m-%d') version_map = [('heat_template_version', '2013-05-23'), ('AWSTemplateFormatVersion', '2010-09-09'), ('HeatTemplateFormatVersion', '2012-12-12')] for raw_template in raw_templates: for key, date in version_map: if key in raw_template.template: template = copy.deepcopy(raw_template.template) version = template[key] try: dt = time.strptime(version, '%Y-%m-%d') except (TypeError, ValueError): dt = None if dt is None or dt < patch_date: template[key] = date raw_template.template = template session.commit() def downgrade(migrate_engine): migrate_util.log.warning(_('This version cannot be downgraded because ' 'it involves a data migration to the ' 'raw_template table.')) heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/versions/031_stack_lock.py0000664000567000056700000000272312540642614027104 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. import sqlalchemy def upgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack_lock = sqlalchemy.Table( 'stack_lock', meta, sqlalchemy.Column('stack_id', sqlalchemy.String(length=36), sqlalchemy.ForeignKey('stack.id'), primary_key=True, nullable=False), sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('engine_id', sqlalchemy.String(length=36)), mysql_engine='InnoDB', mysql_charset='utf8' ) sqlalchemy.Table('stack', meta, autoload=True) stack_lock.create() def downgrade(migrate_engine): meta = sqlalchemy.MetaData() meta.bind = migrate_engine stack_lock = sqlalchemy.Table('stack_lock', meta, autoload=True) stack_lock.drop() heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/README0000664000567000056700000000015312540642614023035 0ustar jenkinsjenkins00000000000000This is a database migration repository. More information at http://code.google.com/p/sqlalchemy-migrate/ heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/__init__.py0000664000567000056700000000000012540642611024252 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sqlalchemy/migrate_repo/manage.py0000775000567000056700000000016412540642611023761 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python from migrate.versioning.shell import main if __name__ == '__main__': main(debug='False') heat-2014.1.5/heat/db/sqlalchemy/mutable.py0000664000567000056700000000355712540642614021516 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. # # The MIT License # # ext/mutable.py # Copyright (C) 2005-2013 the SQLAlchemy authors # and contributors # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/lic enses/mit-license.php """ Submitted on behalf of a third-party: sqlalchemy """ from sqlalchemy.ext.mutable import Mutable class MutableDict(Mutable, dict): """A dictionary type that implements :class:`.Mutable`. .. versionadded:: 0.8 """ def __setitem__(self, key, value): """Detect dictionary set events and emit change events.""" dict.__setitem__(self, key, value) self.changed() def __delitem__(self, key): """Detect dictionary del events and emit change events.""" dict.__delitem__(self, key) self.changed() def clear(self): dict.clear(self) self.changed() @classmethod def coerce(cls, key, value): """Convert plain dictionary to MutableDict.""" if not isinstance(value, MutableDict): if isinstance(value, dict): return MutableDict(value) return Mutable.coerce(key, value) else: return value def __getstate__(self): return dict(self) def __setstate__(self, state): self.update(state) heat-2014.1.5/heat/db/sqlalchemy/filters.py0000664000567000056700000000304112540642614021521 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. def exact_filter(query, model, filters): """Applies exact match filtering to a query. Returns the updated query. Modifies filters argument to remove filters consumed. :param query: query to apply filters to :param model: model object the query applies to, for IN-style filtering :param filters: dictionary of filters; values that are lists, tuples, sets, or frozensets cause an 'IN' test to be performed, while exact matching ('==' operator) is used for other values """ filter_dict = {} if filters is None: filters = {} for key, value in filters.iteritems(): if isinstance(value, (list, tuple, set, frozenset)): column_attr = getattr(model, key) query = query.filter(column_attr.in_(value)) else: filter_dict[key] = value if filter_dict: query = query.filter_by(**filter_dict) return query heat-2014.1.5/heat/db/sqlalchemy/models.py0000664000567000056700000002735212540642614021347 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. """ SQLAlchemy models for heat data. """ import uuid import sqlalchemy from sqlalchemy.orm import relationship, backref from sqlalchemy.ext.declarative import declarative_base from heat.openstack.common import timeutils from heat.openstack.common.db.sqlalchemy import models from heat.openstack.common.db.sqlalchemy import session from sqlalchemy.orm.session import Session from heat.db.sqlalchemy.types import Json BASE = declarative_base() get_session = session.get_session class HeatBase(models.ModelBase, models.TimestampMixin): """Base class for Heat Models.""" __table_args__ = {'mysql_engine': 'InnoDB'} def expire(self, session=None, attrs=None): """Expire this object ().""" if not session: session = Session.object_session(self) if not session: session = get_session() session.expire(self, attrs) def refresh(self, session=None, attrs=None): """Refresh this object.""" if not session: session = Session.object_session(self) if not session: session = get_session() session.refresh(self, attrs) def delete(self, session=None): """Delete this object.""" if not session: session = Session.object_session(self) if not session: session = get_session() session.delete(self) session.flush() def update_and_save(self, values, session=None): if not session: session = Session.object_session(self) if not session: session = get_session() session.begin() for k, v in values.iteritems(): setattr(self, k, v) session.commit() class SoftDelete(object): deleted_at = sqlalchemy.Column(sqlalchemy.DateTime) def soft_delete(self, session=None): """Mark this object as deleted.""" self.update_and_save({'deleted_at': timeutils.utcnow()}, session=session) class StateAware(object): action = sqlalchemy.Column('action', sqlalchemy.String(255)) status = sqlalchemy.Column('status', sqlalchemy.String(255)) _status_reason = sqlalchemy.Column('status_reason', sqlalchemy.String(255)) @property def status_reason(self): return self._status_reason @status_reason.setter def status_reason(self, reason): self._status_reason = reason and reason[:255] or '' class RawTemplate(BASE, HeatBase): """Represents an unparsed template which should be in JSON format.""" __tablename__ = 'raw_template' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) template = sqlalchemy.Column(Json) files = sqlalchemy.Column(Json) class Stack(BASE, HeatBase, SoftDelete, StateAware): """Represents a stack created by the heat engine.""" __tablename__ = 'stack' id = sqlalchemy.Column(sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) name = sqlalchemy.Column(sqlalchemy.String(255)) raw_template_id = sqlalchemy.Column( sqlalchemy.Integer, sqlalchemy.ForeignKey('raw_template.id'), nullable=False) raw_template = relationship(RawTemplate, backref=backref('stack')) username = sqlalchemy.Column(sqlalchemy.String(256)) tenant = sqlalchemy.Column(sqlalchemy.String(256)) parameters = sqlalchemy.Column('parameters', Json) user_creds_id = sqlalchemy.Column( sqlalchemy.Integer, sqlalchemy.ForeignKey('user_creds.id'), nullable=False) owner_id = sqlalchemy.Column(sqlalchemy.String(36), nullable=True) timeout = sqlalchemy.Column(sqlalchemy.Integer) disable_rollback = sqlalchemy.Column(sqlalchemy.Boolean, nullable=False) stack_user_project_id = sqlalchemy.Column(sqlalchemy.String(64), nullable=True) # Override timestamp column to store the correct value: it should be the # time the create/update call was issued, not the time the DB entry is # created/modified. (bug #1193269) updated_at = sqlalchemy.Column(sqlalchemy.DateTime) class StackLock(BASE, HeatBase): """Store stack locks for deployments with multiple-engines.""" __tablename__ = 'stack_lock' stack_id = sqlalchemy.Column(sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), primary_key=True) engine_id = sqlalchemy.Column(sqlalchemy.String(36)) class UserCreds(BASE, HeatBase): """ Represents user credentials and mirrors the 'context' handed in by wsgi. """ __tablename__ = 'user_creds' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) username = sqlalchemy.Column(sqlalchemy.String(255)) password = sqlalchemy.Column(sqlalchemy.String(255)) decrypt_method = sqlalchemy.Column(sqlalchemy.String(64)) tenant = sqlalchemy.Column(sqlalchemy.String(1024)) auth_url = sqlalchemy.Column(sqlalchemy.String) tenant_id = sqlalchemy.Column(sqlalchemy.String(256)) trust_id = sqlalchemy.Column(sqlalchemy.String(255)) trustor_user_id = sqlalchemy.Column(sqlalchemy.String(64)) stack = relationship(Stack, backref=backref('user_creds')) class Event(BASE, HeatBase): """Represents an event generated by the heat engine.""" __tablename__ = 'event' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) stack_id = sqlalchemy.Column(sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), nullable=False) stack = relationship(Stack, backref=backref('events')) uuid = sqlalchemy.Column(sqlalchemy.String(36), default=lambda: str(uuid.uuid4()), unique=True) resource_action = sqlalchemy.Column(sqlalchemy.String(255)) resource_status = sqlalchemy.Column(sqlalchemy.String(255)) resource_name = sqlalchemy.Column(sqlalchemy.String(255)) physical_resource_id = sqlalchemy.Column(sqlalchemy.String(255)) _resource_status_reason = sqlalchemy.Column( 'resource_status_reason', sqlalchemy.String(255)) resource_type = sqlalchemy.Column(sqlalchemy.String(255)) resource_properties = sqlalchemy.Column(sqlalchemy.PickleType) @property def resource_status_reason(self): return self._resource_status_reason @resource_status_reason.setter def resource_status_reason(self, reason): self._resource_status_reason = reason and reason[:255] or '' class ResourceData(BASE, HeatBase): """Key/value store of arbitrary, resource-specific data.""" __tablename__ = 'resource_data' id = sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True, nullable=False) key = sqlalchemy.Column('key', sqlalchemy.String(255)) value = sqlalchemy.Column('value', sqlalchemy.String) redact = sqlalchemy.Column('redact', sqlalchemy.Boolean) decrypt_method = sqlalchemy.Column(sqlalchemy.String(64)) resource_id = sqlalchemy.Column('resource_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('resource.id'), nullable=False) class Resource(BASE, HeatBase, StateAware): """Represents a resource created by the heat engine.""" __tablename__ = 'resource' id = sqlalchemy.Column(sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) name = sqlalchemy.Column('name', sqlalchemy.String(255), nullable=True) nova_instance = sqlalchemy.Column('nova_instance', sqlalchemy.String(255)) # odd name as "metadata" is reserved rsrc_metadata = sqlalchemy.Column('rsrc_metadata', Json) stack_id = sqlalchemy.Column(sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), nullable=False) stack = relationship(Stack, backref=backref('resources')) data = relationship(ResourceData, cascade="all,delete", backref=backref('resource')) # Override timestamp column to store the correct value: it should be the # time the create/update call was issued, not the time the DB entry is # created/modified. (bug #1193269) updated_at = sqlalchemy.Column(sqlalchemy.DateTime) class WatchRule(BASE, HeatBase): """Represents a watch_rule created by the heat engine.""" __tablename__ = 'watch_rule' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) name = sqlalchemy.Column('name', sqlalchemy.String(255), nullable=True) rule = sqlalchemy.Column('rule', Json) state = sqlalchemy.Column('state', sqlalchemy.String(255)) last_evaluated = sqlalchemy.Column(sqlalchemy.DateTime, default=timeutils.utcnow) stack_id = sqlalchemy.Column(sqlalchemy.String(36), sqlalchemy.ForeignKey('stack.id'), nullable=False) stack = relationship(Stack, backref=backref('watch_rule')) class WatchData(BASE, HeatBase): """Represents a watch_data created by the heat engine.""" __tablename__ = 'watch_data' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) data = sqlalchemy.Column('data', Json) watch_rule_id = sqlalchemy.Column( sqlalchemy.Integer, sqlalchemy.ForeignKey('watch_rule.id'), nullable=False) watch_rule = relationship(WatchRule, backref=backref('watch_data')) class SoftwareConfig(BASE, HeatBase): """ Represents a software configuration resource to be applied to one or more servers. """ __tablename__ = 'software_config' id = sqlalchemy.Column('id', sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) name = sqlalchemy.Column('name', sqlalchemy.String(255), nullable=True) group = sqlalchemy.Column('group', sqlalchemy.String(255)) config = sqlalchemy.Column('config', Json) tenant = sqlalchemy.Column( 'tenant', sqlalchemy.String(64), nullable=False) class SoftwareDeployment(BASE, HeatBase, StateAware): """ Represents applying a software configuration resource to a single server resource. """ __tablename__ = 'software_deployment' id = sqlalchemy.Column('id', sqlalchemy.String(36), primary_key=True, default=lambda: str(uuid.uuid4())) config_id = sqlalchemy.Column( 'config_id', sqlalchemy.String(36), sqlalchemy.ForeignKey('software_config.id'), nullable=False) config = relationship(SoftwareConfig, backref=backref('deployments')) server_id = sqlalchemy.Column('server_id', sqlalchemy.String(36), nullable=False) input_values = sqlalchemy.Column('input_values', Json) output_values = sqlalchemy.Column('output_values', Json) tenant = sqlalchemy.Column( 'tenant', sqlalchemy.String(64), nullable=False) stack_user_project_id = sqlalchemy.Column(sqlalchemy.String(64), nullable=True) heat-2014.1.5/heat/db/sqlalchemy/__init__.py0000664000567000056700000000000012540642611021575 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/sqlalchemy/api.py0000664000567000056700000005564712540642614020645 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. '''Implementation of SQLAlchemy backend.''' import sys from datetime import datetime from datetime import timedelta from oslo.config import cfg import sqlalchemy from sqlalchemy.orm.session import Session cfg.CONF.import_opt('max_events_per_stack', 'heat.common.config') from heat.openstack.common.gettextutils import _ from heat.common import crypt from heat.common import exception from heat.db.sqlalchemy import filters as db_filters from heat.db.sqlalchemy import migration from heat.db.sqlalchemy import models from heat.openstack.common.db.sqlalchemy import session as db_session from heat.openstack.common.db.sqlalchemy import utils get_engine = db_session.get_engine get_session = db_session.get_session def get_backend(): """The backend is this module itself.""" return sys.modules[__name__] def model_query(context, *args): session = _session(context) query = session.query(*args) return query def soft_delete_aware_query(context, *args, **kwargs): """Stack query helper that accounts for context's `show_deleted` field. :param show_deleted: if True, overrides context's show_deleted field. """ query = model_query(context, *args) show_deleted = kwargs.get('show_deleted') or context.show_deleted if not show_deleted: query = query.filter_by(deleted_at=None) return query def _session(context): return (context and context.session) or get_session() def raw_template_get(context, template_id): result = model_query(context, models.RawTemplate).get(template_id) if not result: raise exception.NotFound(_('raw template with id %s not found') % template_id) return result def raw_template_create(context, values): raw_template_ref = models.RawTemplate() raw_template_ref.update(values) raw_template_ref.save(_session(context)) return raw_template_ref def resource_get(context, resource_id): result = model_query(context, models.Resource).get(resource_id) if not result: raise exception.NotFound(_("resource with id %s not found") % resource_id) return result def resource_get_by_name_and_stack(context, resource_name, stack_id): result = model_query(context, models.Resource).\ filter_by(name=resource_name).\ filter_by(stack_id=stack_id).first() return result def resource_get_by_physical_resource_id(context, physical_resource_id): results = (model_query(context, models.Resource) .filter_by(nova_instance=physical_resource_id) .all()) for result in results: if context is None or result.stack.tenant == context.tenant_id: return result return None def resource_get_all(context): results = model_query(context, models.Resource).all() if not results: raise exception.NotFound(_('no resources were found')) return results def resource_data_get_all(resource): """ Looks up resource_data by resource.id. If data is encrypted, this method will decrypt the results. """ result = (model_query(resource.context, models.ResourceData) .filter_by(resource_id=resource.id)) if not result: raise exception.NotFound(_('no resource data found')) ret = {} for res in result: if res.redact: ret[res.key] = _decrypt(res.value, res.decrypt_method) else: ret[res.key] = res.value return ret def resource_data_get(resource, key): """Lookup value of resource's data by key. Decrypts resource data if necessary. """ result = resource_data_get_by_key(resource.context, resource.id, key) if result.redact: return _decrypt(result.value, result.decrypt_method) return result.value def _encrypt(value): if value is not None: return crypt.encrypt(value.encode('utf-8')) else: return None, None def _decrypt(enc_value, method): if method is None: return None decryptor = getattr(crypt, method) value = decryptor(enc_value) if value is not None: return unicode(value, 'utf-8') def resource_data_get_by_key(context, resource_id, key): """Looks up resource_data by resource_id and key. Does not unencrypt resource_data. """ result = (model_query(context, models.ResourceData) .filter_by(resource_id=resource_id) .filter_by(key=key).first()) if not result: raise exception.NotFound(_('No resource data found')) return result def resource_data_set(resource, key, value, redact=False): """Save resource's key/value pair to database.""" if redact: method, value = _encrypt(value) else: method = '' try: current = resource_data_get_by_key(resource.context, resource.id, key) except exception.NotFound: current = models.ResourceData() current.key = key current.resource_id = resource.id current.redact = redact current.value = value current.decrypt_method = method current.save(session=resource.context.session) return current def resource_exchange_stacks(context, resource_id1, resource_id2): query = model_query(context, models.Resource) session = query.session session.begin() res1 = query.get(resource_id1) res2 = query.get(resource_id2) res1.stack, res2.stack = res2.stack, res1.stack session.commit() def resource_data_delete(resource, key): result = resource_data_get_by_key(resource.context, resource.id, key) result.delete() def resource_create(context, values): resource_ref = models.Resource() resource_ref.update(values) resource_ref.save(_session(context)) return resource_ref def resource_get_all_by_stack(context, stack_id): results = model_query(context, models.Resource).\ filter_by(stack_id=stack_id).all() if not results: raise exception.NotFound(_("no resources for stack_id %s were found") % stack_id) return results def stack_get_by_name_and_owner_id(context, stack_name, owner_id): query = soft_delete_aware_query(context, models.Stack).\ filter(sqlalchemy.or_( models.Stack.tenant == context.tenant_id, models.Stack.stack_user_project_id == context.tenant_id )).\ filter_by(name=stack_name).\ filter_by(owner_id=owner_id) return query.first() def stack_get_by_name(context, stack_name): query = soft_delete_aware_query(context, models.Stack).\ filter(sqlalchemy.or_( models.Stack.tenant == context.tenant_id, models.Stack.stack_user_project_id == context.tenant_id )).\ filter_by(name=stack_name) return query.first() def stack_get(context, stack_id, show_deleted=False, tenant_safe=True): result = model_query(context, models.Stack).get(stack_id) deleted_ok = show_deleted or context.show_deleted if result is None or result.deleted_at is not None and not deleted_ok: return None # One exception to normal project scoping is users created by the # stacks in the stack_user_project_id (in the heat stack user domain) if (tenant_safe and result is not None and context is not None and context.tenant_id not in (result.tenant, result.stack_user_project_id)): return None return result def stack_get_all_by_owner_id(context, owner_id): results = soft_delete_aware_query(context, models.Stack).\ filter_by(owner_id=owner_id).all() return results def _filter_sort_keys(sort_keys, whitelist): '''Returns an array containing only whitelisted keys :param sort_keys: an array of strings :param whitelist: an array of allowed strings :returns: filtered list of sort keys ''' if not sort_keys: return [] elif not isinstance(sort_keys, list): sort_keys = [sort_keys] return [key for key in sort_keys if key in whitelist] def _paginate_query(context, query, model, limit=None, sort_keys=None, marker=None, sort_dir=None): default_sort_keys = ['created_at'] if not sort_keys: sort_keys = default_sort_keys if not sort_dir: sort_dir = 'desc' # This assures the order of the stacks will always be the same # even for sort_key values that are not unique in the database sort_keys = sort_keys + ['id'] model_marker = None if marker: model_marker = model_query(context, model).get(marker) try: query = utils.paginate_query(query, model, limit, sort_keys, model_marker, sort_dir) except utils.InvalidSortKey as exc: raise exception.Invalid(reason=exc.message) return query def _query_stack_get_all(context, tenant_safe=True): query = soft_delete_aware_query(context, models.Stack).\ filter_by(owner_id=None) if tenant_safe: query = query.filter_by(tenant=context.tenant_id) return query def stack_get_all(context, limit=None, sort_keys=None, marker=None, sort_dir=None, filters=None, tenant_safe=True): query = _query_stack_get_all(context, tenant_safe) return _filter_and_page_query(context, query, limit, sort_keys, marker, sort_dir, filters).all() def _filter_and_page_query(context, query, limit=None, sort_keys=None, marker=None, sort_dir=None, filters=None): if filters is None: filters = {} allowed_sort_keys = [models.Stack.name.key, models.Stack.status.key, models.Stack.created_at.key, models.Stack.updated_at.key] whitelisted_sort_keys = _filter_sort_keys(sort_keys, allowed_sort_keys) query = db_filters.exact_filter(query, models.Stack, filters) return _paginate_query(context, query, models.Stack, limit, whitelisted_sort_keys, marker, sort_dir) def stack_count_all(context, filters=None, tenant_safe=True): query = _query_stack_get_all(context, tenant_safe=tenant_safe) query = db_filters.exact_filter(query, models.Stack, filters) return query.count() def stack_create(context, values): stack_ref = models.Stack() stack_ref.update(values) stack_ref.save(_session(context)) return stack_ref def stack_update(context, stack_id, values): stack = stack_get(context, stack_id) if not stack: raise exception.NotFound(_('Attempt to update a stack with id: ' '%(id)s %(msg)s') % { 'id': stack_id, 'msg': 'that does not exist'}) stack.update(values) stack.save(_session(context)) def stack_delete(context, stack_id): s = stack_get(context, stack_id) if not s: raise exception.NotFound(_('Attempt to delete a stack with id: ' '%(id)s %(msg)s') % { 'id': stack_id, 'msg': 'that does not exist'}) session = Session.object_session(s) for r in s.resources: session.delete(r) s.soft_delete(session=session) session.flush() def stack_lock_create(stack_id, engine_id): session = get_session() with session.begin(): lock = session.query(models.StackLock).get(stack_id) if lock is not None: return lock.engine_id session.add(models.StackLock(stack_id=stack_id, engine_id=engine_id)) def stack_lock_steal(stack_id, old_engine_id, new_engine_id): session = get_session() with session.begin(): lock = session.query(models.StackLock).get(stack_id) rows_affected = session.query(models.StackLock).\ filter_by(stack_id=stack_id, engine_id=old_engine_id).\ update({"engine_id": new_engine_id}) if not rows_affected: return lock.engine_id if lock is not None else True def stack_lock_release(stack_id, engine_id): session = get_session() with session.begin(): rows_affected = session.query(models.StackLock).\ filter_by(stack_id=stack_id, engine_id=engine_id).\ delete() if not rows_affected: return True def user_creds_create(context): values = context.to_dict() user_creds_ref = models.UserCreds() if values.get('trust_id'): method, trust_id = _encrypt(values.get('trust_id')) user_creds_ref.trust_id = trust_id user_creds_ref.decrypt_method = method user_creds_ref.trustor_user_id = values.get('trustor_user_id') user_creds_ref.username = None user_creds_ref.password = None user_creds_ref.tenant = values.get('tenant') user_creds_ref.tenant_id = values.get('tenant_id') else: user_creds_ref.update(values) method, password = _encrypt(values['password']) user_creds_ref.password = password user_creds_ref.decrypt_method = method user_creds_ref.save(_session(context)) return user_creds_ref def user_creds_get(user_creds_id): db_result = model_query(None, models.UserCreds).get(user_creds_id) if db_result is None: return None # Return a dict copy of db results, do not decrypt details into db_result # or it can be committed back to the DB in decrypted form result = dict(db_result) del result['decrypt_method'] result['password'] = _decrypt(result['password'], db_result.decrypt_method) result['trust_id'] = _decrypt(result['trust_id'], db_result.decrypt_method) return result def user_creds_delete(context, user_creds_id): creds = model_query(context, models.UserCreds).get(user_creds_id) if not creds: raise exception.NotFound( _('Attempt to delete user creds with id ' '%(id)s that does not exist') % {'id': user_creds_id}) session = Session.object_session(creds) session.delete(creds) session.flush() def event_get(context, event_id): result = model_query(context, models.Event).get(event_id) return result def event_get_all(context): stacks = soft_delete_aware_query(context, models.Stack) stack_ids = [stack.id for stack in stacks] results = model_query(context, models.Event).\ filter(models.Event.stack_id.in_(stack_ids)).all() return results def event_get_all_by_tenant(context): stacks = soft_delete_aware_query(context, models.Stack).\ filter_by(tenant=context.tenant_id).all() results = [] for stack in stacks: results.extend(model_query(context, models.Event). filter_by(stack_id=stack.id).all()) return results def _query_all_by_stack(context, stack_id): query = model_query(context, models.Event).\ filter_by(stack_id=stack_id) return query def event_get_all_by_stack(context, stack_id): return _query_all_by_stack(context, stack_id).all() def event_count_all_by_stack(context, stack_id): return _query_all_by_stack(context, stack_id).count() def _delete_event_rows(context, stack_id, limit): # MySQL does not support LIMIT in subqueries, # sqlite does not support JOIN in DELETE. # So we must manually supply the IN() values. # pgsql SHOULD work with the pure DELETE/JOIN below but that must be # confirmed via integration tests. query = _query_all_by_stack(context, stack_id) session = _session(context) if 'postgres' not in session.connection().dialect.name: ids = [r.id for r in query.order_by( models.Event.id).limit(limit).all()] q = session.query(models.Event).filter( models.Event.id.in_(ids)) else: stmt = session.query( models.Event.id).filter_by( stack_id=stack_id).order_by( models.Event.id).limit(limit).subquery() q = query.join(stmt, models.Event.id == stmt.c.id) return q.delete(synchronize_session='fetch') def event_create(context, values): if 'stack_id' in values and cfg.CONF.max_events_per_stack: if ((event_count_all_by_stack(context, values['stack_id']) >= cfg.CONF.max_events_per_stack)): # prune _delete_event_rows( context, values['stack_id'], cfg.CONF.event_purge_batch_size) event_ref = models.Event() event_ref.update(values) event_ref.save(_session(context)) return event_ref def watch_rule_get(context, watch_rule_id): result = model_query(context, models.WatchRule).get(watch_rule_id) return result def watch_rule_get_by_name(context, watch_rule_name): result = model_query(context, models.WatchRule).\ filter_by(name=watch_rule_name).first() return result def watch_rule_get_all(context): results = model_query(context, models.WatchRule).all() return results def watch_rule_get_all_by_stack(context, stack_id): results = model_query(context, models.WatchRule).\ filter_by(stack_id=stack_id).all() return results def watch_rule_create(context, values): obj_ref = models.WatchRule() obj_ref.update(values) obj_ref.save(_session(context)) return obj_ref def watch_rule_update(context, watch_id, values): wr = watch_rule_get(context, watch_id) if not wr: raise exception.NotFound(_('Attempt to update a watch with id: ' '%(id)s %(msg)s') % { 'id': watch_id, 'msg': 'that does not exist'}) wr.update(values) wr.save(_session(context)) def watch_rule_delete(context, watch_id): wr = watch_rule_get(context, watch_id) if not wr: raise exception.NotFound(_('Attempt to delete watch_rule: ' '%(id)s %(msg)s') % { 'id': watch_id, 'msg': 'that does not exist'}) session = Session.object_session(wr) for d in wr.watch_data: session.delete(d) session.delete(wr) session.flush() def watch_data_create(context, values): obj_ref = models.WatchData() obj_ref.update(values) obj_ref.save(_session(context)) return obj_ref def watch_data_get_all(context): results = model_query(context, models.WatchData).all() return results def software_config_create(context, values): obj_ref = models.SoftwareConfig() obj_ref.update(values) obj_ref.save(_session(context)) return obj_ref def software_config_get(context, config_id): result = model_query(context, models.SoftwareConfig).get(config_id) if (result is not None and context is not None and result.tenant != context.tenant_id): result = None if not result: raise exception.NotFound(_('Software config with id %s not found') % config_id) return result def software_config_delete(context, config_id): config = software_config_get(context, config_id) session = Session.object_session(config) session.delete(config) session.flush() def software_deployment_create(context, values): obj_ref = models.SoftwareDeployment() obj_ref.update(values) obj_ref.save(_session(context)) return obj_ref def software_deployment_get(context, deployment_id): result = model_query(context, models.SoftwareDeployment).get(deployment_id) if (result is not None and context is not None and context.tenant_id not in (result.tenant, result.stack_user_project_id)): result = None if not result: raise exception.NotFound(_('Deployment with id %s not found') % deployment_id) return result def software_deployment_get_all(context, server_id=None): sd = models.SoftwareDeployment query = model_query(context, sd).\ filter(sqlalchemy.or_( sd.tenant == context.tenant_id, sd.stack_user_project_id == context.tenant_id )).\ order_by(sd.created_at) if server_id: query = query.filter_by(server_id=server_id) return query.all() def software_deployment_update(context, deployment_id, values): deployment = software_deployment_get(context, deployment_id) deployment.update(values) deployment.save(_session(context)) return deployment def software_deployment_delete(context, deployment_id): deployment = software_deployment_get(context, deployment_id) session = Session.object_session(deployment) session.delete(deployment) session.flush() def purge_deleted(age, granularity='days'): try: age = int(age) except ValueError: raise exception.Error(_("age should be an integer")) if age < 0: raise exception.Error(_("age should be a positive integer")) if granularity not in ('days', 'hours', 'minutes', 'seconds'): raise exception.Error( _("granularity should be days, hours, minutes, or seconds")) if granularity == 'days': age = age * 86400 elif granularity == 'hours': age = age * 3600 elif granularity == 'minutes': age = age * 60 time_line = datetime.now() - timedelta(seconds=age) engine = get_engine() meta = sqlalchemy.MetaData() meta.bind = engine stack = sqlalchemy.Table('stack', meta, autoload=True) event = sqlalchemy.Table('event', meta, autoload=True) raw_template = sqlalchemy.Table('raw_template', meta, autoload=True) user_creds = sqlalchemy.Table('user_creds', meta, autoload=True) stmt = sqlalchemy.select([stack.c.id, stack.c.raw_template_id, stack.c.user_creds_id]).\ where(stack.c.deleted_at < time_line) deleted_stacks = engine.execute(stmt) for s in deleted_stacks: event_del = event.delete().where(event.c.stack_id == s[0]) engine.execute(event_del) stack_del = stack.delete().where(stack.c.id == s[0]) engine.execute(stack_del) raw_template_del = raw_template.delete().\ where(raw_template.c.id == s[1]) engine.execute(raw_template_del) user_creds_del = user_creds.delete().where(user_creds.c.id == s[2]) engine.execute(user_creds_del) def db_sync(version=None): """Migrate the database to `version` or the most recent version.""" return migration.db_sync(version=version) def db_version(): """Display the current database version.""" return migration.db_version() heat-2014.1.5/heat/db/sqlalchemy/migration.py0000664000567000056700000000240612540642614022046 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. import os from heat.openstack.common.db.sqlalchemy import migration as oslo_migration INIT_VERSION = 14 def db_sync(version=None): path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'migrate_repo') return oslo_migration.db_sync(path, version, init_version=INIT_VERSION) def db_version(): path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'migrate_repo') return oslo_migration.db_version(path, INIT_VERSION) def db_version_control(version=None): path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'migrate_repo') return oslo_migration.db_version_control(path, version) heat-2014.1.5/heat/db/__init__.py0000664000567000056700000000000012540642611017433 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/db/api.py0000664000567000056700000001650412540642614016470 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. ''' Interface for database access. Usage: >>> from heat import db >>> db.event_get(context, event_id) # Event object received The underlying driver is loaded . SQLAlchemy is currently the only supported backend. ''' from oslo.config import cfg from heat.openstack.common.db import api as db_api db_opts = [ cfg.StrOpt('db_backend', default='sqlalchemy', help='The backend to use for db.')] CONF = cfg.CONF CONF.register_opts(db_opts) _BACKEND_MAPPING = {'sqlalchemy': 'heat.db.sqlalchemy.api'} IMPL = db_api.DBAPI(backend_mapping=_BACKEND_MAPPING) def get_session(): return IMPL.get_session() def raw_template_get(context, template_id): return IMPL.raw_template_get(context, template_id) def raw_template_create(context, values): return IMPL.raw_template_create(context, values) def resource_data_get_all(resource): return IMPL.resource_data_get_all(resource) def resource_data_get(resource, key): return IMPL.resource_data_get(resource, key) def resource_data_set(resource, key, value, redact=False): return IMPL.resource_data_set(resource, key, value, redact=redact) def resource_data_get_by_key(context, resource_id, key): return IMPL.resource_data_get_by_key(context, resource_id, key) def resource_data_delete(resource, key): """Remove a resource_data element associated to a resource.""" return IMPL.resource_data_delete(resource, key) def resource_get(context, resource_id): return IMPL.resource_get(context, resource_id) def resource_get_all(context): return IMPL.resource_get_all(context) def resource_create(context, values): return IMPL.resource_create(context, values) def resource_exchange_stacks(context, resource_id1, resource_id2): return IMPL.resource_exchange_stacks(context, resource_id1, resource_id2) def resource_get_all_by_stack(context, stack_id): return IMPL.resource_get_all_by_stack(context, stack_id) def resource_get_by_name_and_stack(context, resource_name, stack_id): return IMPL.resource_get_by_name_and_stack(context, resource_name, stack_id) def resource_get_by_physical_resource_id(context, physical_resource_id): return IMPL.resource_get_by_physical_resource_id(context, physical_resource_id) def stack_get(context, stack_id, show_deleted=False, tenant_safe=True): return IMPL.stack_get(context, stack_id, show_deleted=show_deleted, tenant_safe=tenant_safe) def stack_get_by_name_and_owner_id(context, stack_name, owner_id): return IMPL.stack_get_by_name_and_owner_id(context, stack_name, owner_id=owner_id) def stack_get_by_name(context, stack_name): return IMPL.stack_get_by_name(context, stack_name) def stack_get_all(context, limit=None, sort_keys=None, marker=None, sort_dir=None, filters=None, tenant_safe=True): return IMPL.stack_get_all(context, limit, sort_keys, marker, sort_dir, filters, tenant_safe) def stack_get_all_by_owner_id(context, owner_id): return IMPL.stack_get_all_by_owner_id(context, owner_id) def stack_count_all(context, filters=None, tenant_safe=True): return IMPL.stack_count_all(context, filters=filters, tenant_safe=tenant_safe) def stack_create(context, values): return IMPL.stack_create(context, values) def stack_update(context, stack_id, values): return IMPL.stack_update(context, stack_id, values) def stack_delete(context, stack_id): return IMPL.stack_delete(context, stack_id) def stack_lock_create(stack_id, engine_id): return IMPL.stack_lock_create(stack_id, engine_id) def stack_lock_steal(stack_id, old_engine_id, new_engine_id): return IMPL.stack_lock_steal(stack_id, old_engine_id, new_engine_id) def stack_lock_release(stack_id, engine_id): return IMPL.stack_lock_release(stack_id, engine_id) def user_creds_create(context): return IMPL.user_creds_create(context) def user_creds_delete(context, user_creds_id): return IMPL.user_creds_delete(context, user_creds_id) def user_creds_get(context_id): return IMPL.user_creds_get(context_id) def event_get(context, event_id): return IMPL.event_get(context, event_id) def event_get_all(context): return IMPL.event_get_all(context) def event_get_all_by_tenant(context): return IMPL.event_get_all_by_tenant(context) def event_get_all_by_stack(context, stack_id): return IMPL.event_get_all_by_stack(context, stack_id) def event_count_all_by_stack(context, stack_id): return IMPL.event_count_all_by_stack(context, stack_id) def event_create(context, values): return IMPL.event_create(context, values) def watch_rule_get(context, watch_rule_id): return IMPL.watch_rule_get(context, watch_rule_id) def watch_rule_get_by_name(context, watch_rule_name): return IMPL.watch_rule_get_by_name(context, watch_rule_name) def watch_rule_get_all(context): return IMPL.watch_rule_get_all(context) def watch_rule_get_all_by_stack(context, stack_id): return IMPL.watch_rule_get_all_by_stack(context, stack_id) def watch_rule_create(context, values): return IMPL.watch_rule_create(context, values) def watch_rule_update(context, watch_id, values): return IMPL.watch_rule_update(context, watch_id, values) def watch_rule_delete(context, watch_id): return IMPL.watch_rule_delete(context, watch_id) def watch_data_create(context, values): return IMPL.watch_data_create(context, values) def watch_data_get_all(context): return IMPL.watch_data_get_all(context) def software_config_create(context, values): return IMPL.software_config_create(context, values) def software_config_get(context, config_id): return IMPL.software_config_get(context, config_id) def software_config_delete(context, config_id): return IMPL.software_config_delete(context, config_id) def software_deployment_create(context, values): return IMPL.software_deployment_create(context, values) def software_deployment_get(context, deployment_id): return IMPL.software_deployment_get(context, deployment_id) def software_deployment_get_all(context, server_id=None): return IMPL.software_deployment_get_all(context, server_id) def software_deployment_update(context, deployment_id, values): return IMPL.software_deployment_update(context, deployment_id, values) def software_deployment_delete(context, deployment_id): return IMPL.software_deployment_delete(context, deployment_id) def db_sync(version=None): """Migrate the database to `version` or the most recent version.""" return IMPL.db_sync(version=version) def db_version(): """Display the current database version.""" return IMPL.db_version() heat-2014.1.5/heat/db/utils.py0000664000567000056700000000301712540642614017052 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. class LazyPluggable(object): """A pluggable backend loaded lazily based on some value.""" def __init__(self, pivot, **backends): self.__backends = backends self.__pivot = pivot self.__backend = None def __get_backend(self): if not self.__backend: backend_name = 'sqlalchemy' backend = self.__backends[backend_name] if isinstance(backend, tuple): name = backend[0] fromlist = backend[1] else: name = backend fromlist = backend self.__backend = __import__(name, None, None, fromlist) return self.__backend def __getattr__(self, key): backend = self.__get_backend() return getattr(backend, key) IMPL = LazyPluggable('db_backend', sqlalchemy='heat.db.sqlalchemy.api') def purge_deleted(age, granularity='days'): IMPL.purge_deleted(age, granularity) heat-2014.1.5/heat/scaling/0000775000567000056700000000000012540643116016370 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/scaling/template.py0000664000567000056700000000301212540642614020553 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. from heat.common import short_id def resource_templates(old_resources, resource_definition, num_resources, num_replace): """ Create the template for the nested stack of existing and new instances For rolling update, if launch configuration is different, the instance definition should come from the existing instance instead of using the new launch configuration. """ old_resources = old_resources[-num_resources:] num_create = num_resources - len(old_resources) num_replace -= num_create for i in range(num_resources): if i < len(old_resources): old_name, old_template = old_resources[i] if old_template != resource_definition and num_replace > 0: num_replace -= 1 yield old_name, resource_definition else: yield old_name, old_template else: yield short_id.generate_id(), resource_definition heat-2014.1.5/heat/scaling/__init__.py0000664000567000056700000000000012540642611020466 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/common/0000775000567000056700000000000012540643116016240 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/common/context.py0000664000567000056700000001401412540642614020300 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. import uuid from heat.common import exception from heat.common import policy from heat.common import wsgi from heat.db import api as db_api from heat.openstack.common import context from heat.openstack.common import importutils from heat.openstack.common import local def generate_request_id(): return 'req-' + str(uuid.uuid4()) class RequestContext(context.RequestContext): """ Stores information about the security context under which the user accesses the system, as well as additional request information. """ def __init__(self, auth_token=None, username=None, password=None, aws_creds=None, tenant=None, user_id=None, tenant_id=None, auth_url=None, roles=None, is_admin=None, read_only=False, show_deleted=False, overwrite=True, trust_id=None, trustor_user_id=None, request_id=None, **kwargs): """ :param overwrite: Set to False to ensure that the greenthread local copy of the index is not overwritten. :param kwargs: Extra arguments that might be present, but we ignore because they possibly came in from older rpc messages. """ super(RequestContext, self).__init__(auth_token=auth_token, user=username, tenant=tenant, is_admin=is_admin, read_only=read_only, show_deleted=show_deleted, request_id=request_id) self.username = username self.user_id = user_id self.password = password self.aws_creds = aws_creds self.tenant_id = tenant_id self.auth_url = auth_url self.roles = roles or [] if overwrite or not hasattr(local.store, 'context'): self.update_store() self._session = None self.trust_id = trust_id self.trustor_user_id = trustor_user_id self.policy = policy.Enforcer() if is_admin is None: self.is_admin = self.policy.check_is_admin(self) else: self.is_admin = is_admin def update_store(self): local.store.context = self @property def session(self): if self._session is None: self._session = db_api.get_session() return self._session def to_dict(self): return {'auth_token': self.auth_token, 'username': self.username, 'user_id': self.user_id, 'password': self.password, 'aws_creds': self.aws_creds, 'tenant': self.tenant, 'tenant_id': self.tenant_id, 'trust_id': self.trust_id, 'trustor_user_id': self.trustor_user_id, 'auth_url': self.auth_url, 'roles': self.roles, 'is_admin': self.is_admin, 'user': self.user, 'request_id': self.request_id, 'show_deleted': self.show_deleted} @classmethod def from_dict(cls, values): return cls(**values) def get_admin_context(show_deleted=False): return RequestContext(is_admin=True, show_deleted=show_deleted) class ContextMiddleware(wsgi.Middleware): def __init__(self, app, conf, **local_conf): # Determine the context class to use self.ctxcls = RequestContext if 'context_class' in local_conf: self.ctxcls = importutils.import_class(local_conf['context_class']) super(ContextMiddleware, self).__init__(app) def make_context(self, *args, **kwargs): """ Create a context with the given arguments. """ return self.ctxcls(*args, **kwargs) def process_request(self, req): """ Extract any authentication information in the request and construct an appropriate context from it. """ headers = req.headers try: username = None password = None aws_creds = None if headers.get('X-Auth-User') is not None: username = headers.get('X-Auth-User') password = headers.get('X-Auth-Key') elif headers.get('X-Auth-EC2-Creds') is not None: aws_creds = headers.get('X-Auth-EC2-Creds') user_id = headers.get('X-User-Id') token = headers.get('X-Auth-Token') tenant = headers.get('X-Tenant-Name') tenant_id = headers.get('X-Tenant-Id') auth_url = headers.get('X-Auth-Url') roles = headers.get('X-Roles') if roles is not None: roles = roles.split(',') except Exception: raise exception.NotAuthenticated() req.context = self.make_context(auth_token=token, tenant=tenant, tenant_id=tenant_id, aws_creds=aws_creds, username=username, user_id=user_id, password=password, auth_url=auth_url, roles=roles) def ContextMiddleware_filter_factory(global_conf, **local_conf): """ Factory method for paste.deploy """ conf = global_conf.copy() conf.update(local_conf) def filter(app): return ContextMiddleware(app, conf) return filter heat-2014.1.5/heat/common/config.py0000664000567000056700000002741212540642614020067 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. """ Routines for configuring Heat """ import copy import logging as sys_logging import os from eventlet.green import socket from oslo.config import cfg from heat.common import wsgi from heat.openstack.common import log as logging from heat.openstack.common import rpc logger = logging.getLogger(__name__) paste_deploy_group = cfg.OptGroup('paste_deploy') paste_deploy_opts = [ cfg.StrOpt('flavor', help=_("The flavor to use.")), cfg.StrOpt('api_paste_config', default="api-paste.ini", help=_("The API paste config file to use."))] service_opts = [ cfg.IntOpt('periodic_interval', default=60, help='Seconds between running periodic tasks.'), cfg.StrOpt('heat_metadata_server_url', default="", help='URL of the Heat metadata server.'), cfg.StrOpt('heat_waitcondition_server_url', default="", help='URL of the Heat waitcondition server.'), cfg.StrOpt('heat_watch_server_url', default="", help='URL of the Heat CloudWatch server.'), cfg.StrOpt('instance_connection_is_secure', default="0", help='Instance connection to CFN/CW API via https.'), cfg.StrOpt('instance_connection_https_validate_certificates', default="1", help='Instance connection to CFN/CW API validate certs if SSL ' 'is used.'), cfg.StrOpt('region_name_for_services', default=None, help='Default region name used to get services endpoints.'), cfg.StrOpt('heat_stack_user_role', default="heat_stack_user", help='Keystone role for heat template-defined users.'), cfg.StrOpt('stack_user_domain', help='Keystone domain ID which contains heat template-defined ' 'users.'), cfg.StrOpt('stack_domain_admin', help='Keystone username, a user with roles sufficient to ' 'manage users and projects in the stack_user_domain.'), cfg.StrOpt('stack_domain_admin_password', help='Keystone password for stack_domain_admin user.'), cfg.IntOpt('max_template_size', default=524288, help='Maximum raw byte size of any template.'), cfg.IntOpt('max_nested_stack_depth', default=3, help='Maximum depth allowed when using nested stacks.')] engine_opts = [ cfg.StrOpt('instance_user', default='ec2-user', help="The default user for new instances. This option " "is deprecated and will be removed in the Juno release. " "If it's empty, Heat will use the default user set up " "with your cloud image (for OS::Nova::Server) or " "'ec2-user' (for AWS::EC2::Instance)."), cfg.StrOpt('instance_driver', default='heat.engine.nova', help='Driver to use for controlling instances.'), cfg.ListOpt('plugin_dirs', default=['/usr/lib64/heat', '/usr/lib/heat'], help='List of directories to search for plug-ins.'), cfg.StrOpt('environment_dir', default='/etc/heat/environment.d', help='The directory to search for environment files.'), cfg.StrOpt('deferred_auth_method', choices=['password', 'trusts'], default='password', help=_('Select deferred auth method, ' 'stored password or trusts.')), cfg.ListOpt('trusts_delegated_roles', default=['heat_stack_owner'], help=_('Subset of trustor roles to be delegated to heat.')), cfg.IntOpt('max_resources_per_stack', default=1000, help='Maximum resources allowed per top-level stack.'), cfg.IntOpt('max_stacks_per_tenant', default=100, help=_('Maximum number of stacks any one tenant may have' ' active at one time.')), cfg.IntOpt('event_purge_batch_size', default=10, help=_('Controls how many events will be pruned whenever a ' ' stack\'s events exceed max_events_per_stack. Set this' ' lower to keep more events at the expense of more' ' frequent purges.')), cfg.IntOpt('max_events_per_stack', default=1000, help=_('Maximum events that will be available per stack. Older' ' events will be deleted when this is reached. Set to 0' ' for unlimited events per stack.')), cfg.IntOpt('stack_action_timeout', default=3600, help=_('Timeout in seconds for stack action (ie. create or' ' update).')), cfg.IntOpt('engine_life_check_timeout', default=2, help=_('RPC timeout for the engine liveness check that is used' ' for stack locking.')), cfg.StrOpt('onready', help=_('onready allows you to send a notification when the' ' heat processes are ready to serve. This is either a' ' module with the notify() method or a shell command. ' ' To enable notifications with systemd, one may use' ' the \'systemd-notify --ready\' shell command or' ' the \'heat.common.systemd\' notification module.'))] rpc_opts = [ cfg.StrOpt('host', default=socket.gethostname(), help='Name of the engine node. ' 'This can be an opaque identifier. ' 'It is not necessarily a hostname, FQDN, or IP address.')] auth_password_group = cfg.OptGroup('auth_password') auth_password_opts = [ cfg.BoolOpt('multi_cloud', default=False, help=_('Allow orchestration of multiple clouds.')), cfg.ListOpt('allowed_auth_uris', default=[], help=_('Allowed keystone endpoints for auth_uri when ' 'multi_cloud is enabled. At least one endpoint needs ' 'to be specified.'))] clients_opts = [ cfg.StrOpt('endpoint_type', default='publicURL', help=_( 'Type of endpoint in Identity service catalog to use ' 'for communication with the OpenStack service.')), cfg.StrOpt('ca_file', help=_('Optional CA cert file to use in SSL connections.')), cfg.StrOpt('cert_file', help=_('Optional PEM-formatted certificate chain file.')), cfg.StrOpt('key_file', help=_('Optional PEM-formatted file that contains the ' 'private key.')), cfg.BoolOpt('insecure', default=False, help=_("If set, then the server's certificate will not " "be verified."))] def register_clients_opts(): cfg.CONF.register_opts(clients_opts, group='clients') for client in ('nova', 'swift', 'neutron', 'cinder', 'ceilometer', 'keystone', 'heat', 'trove'): client_specific_group = 'clients_' + client # register opts copy and put it to globals in order to # generate_sample.sh to work opts_copy = copy.deepcopy(clients_opts) if client == 'heat': opts_copy.append( cfg.StrOpt('url', help=_('Optional heat url in format like' ' http://0.0.0.0:8004/v1/%(tenant_id)s.'))) globals()[client_specific_group + '_opts'] = opts_copy cfg.CONF.register_opts(opts_copy, group=client_specific_group) revision_group = cfg.OptGroup('revision') revision_opts = [ cfg.StrOpt('heat_revision', default='unknown', help=_('Heat build revision. ' 'If you would prefer to manage your build revision ' 'separately, you can move this section to a different ' 'file and add it as another config option.'))] cfg.CONF.register_opts(engine_opts) cfg.CONF.register_opts(service_opts) cfg.CONF.register_opts(rpc_opts) rpc.set_defaults(control_exchange='heat') cfg.CONF.register_group(paste_deploy_group) cfg.CONF.register_opts(paste_deploy_opts, group=paste_deploy_group) cfg.CONF.register_group(auth_password_group) cfg.CONF.register_opts(auth_password_opts, group=auth_password_group) cfg.CONF.register_group(revision_group) cfg.CONF.register_opts(revision_opts, group=revision_group) register_clients_opts() # A bit of history: # This was added initially by jianingy, then it got added # to oslo by Luis. Then it was receintly removed from the # default list again. # I am not sure we can (or should) rely on oslo to keep # our exceptions class in the defaults list. allowed_rpc_exception_modules = cfg.CONF.allowed_rpc_exception_modules allowed_rpc_exception_modules.append('heat.common.exception') cfg.CONF.set_default(name='allowed_rpc_exception_modules', default=allowed_rpc_exception_modules) if cfg.CONF.instance_user: logger.warn(_('The "instance_user" option in heat.conf is deprecated and ' 'will be removed in the Juno release.')) def _get_deployment_flavor(): """ Retrieve the paste_deploy.flavor config item, formatted appropriately for appending to the application name. """ flavor = cfg.CONF.paste_deploy.flavor return '' if not flavor else ('-' + flavor) def _get_deployment_config_file(): """ Retrieve the deployment_config_file config item, formatted as an absolute pathname. """ config_path = cfg.CONF.find_file( cfg.CONF.paste_deploy['api_paste_config']) if config_path is None: return None return os.path.abspath(config_path) def load_paste_app(app_name=None): """ Builds and returns a WSGI app from a paste config file. We assume the last config file specified in the supplied ConfigOpts object is the paste config file. :param app_name: name of the application to load :raises RuntimeError when config file cannot be located or application cannot be loaded from config file """ if app_name is None: app_name = cfg.CONF.prog # append the deployment flavor to the application name, # in order to identify the appropriate paste pipeline app_name += _get_deployment_flavor() conf_file = _get_deployment_config_file() if conf_file is None: raise RuntimeError(_("Unable to locate config file")) try: app = wsgi.paste_deploy_app(conf_file, app_name, cfg.CONF) # Log the options used when starting if we're in debug mode... if cfg.CONF.debug: cfg.CONF.log_opt_values(logging.getLogger(app_name), sys_logging.DEBUG) return app except (LookupError, ImportError) as e: raise RuntimeError(_("Unable to load %(app_name)s from " "configuration file %(conf_file)s." "\nGot: %(e)r") % {'app_name': app_name, 'conf_file': conf_file, 'e': e}) heat-2014.1.5/heat/common/timeutils.py0000664000567000056700000000243212540642614020634 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. """ Utilities for handling ISO 8601 duration format. """ import re iso_duration_re = re.compile('PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$') def parse_isoduration(duration): """ Convert duration in ISO 8601 format to second(s). Year, Month, Week, and Day designators are not supported. Example: 'PT12H30M5S' """ result = iso_duration_re.match(duration) if not result: raise ValueError(_('Only ISO 8601 duration format of the form ' 'PT#H#M#S is supported.')) t = 0 t += (3600 * int(result.group(1))) if result.group(1) else 0 t += (60 * int(result.group(2))) if result.group(2) else 0 t += int(result.group(3)) if result.group(3) else 0 return t heat-2014.1.5/heat/common/urlfetch.py0000664000567000056700000000533712540642614020440 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. ''' Utility for fetching a resource (e.g. a template) from a URL. ''' from oslo.config import cfg import requests from requests import exceptions from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils cfg.CONF.import_opt('max_template_size', 'heat.common.config') logger = logging.getLogger(__name__) def get(url, allowed_schemes=('http', 'https')): ''' Get the data at the specifier URL. The URL must use the http: or https: schemes. The file: scheme is also supported if you override the allowed_schemes argument. Raise an IOError if getting the data fails. ''' logger.info(_('Fetching data from %s') % url) components = urlutils.urlparse(url) if components.scheme not in allowed_schemes: raise IOError(_('Invalid URL scheme %s') % components.scheme) if components.scheme == 'file': try: return urlutils.urlopen(url).read() except urlutils.URLError as uex: raise IOError(_('Failed to retrieve template: %s') % str(uex)) try: resp = requests.get(url, stream=True) resp.raise_for_status() # We cannot use resp.text here because it would download the # entire file, and a large enough file would bring down the # engine. The 'Content-Length' header could be faked, so it's # necessary to download the content in chunks to until # max_template_size is reached. The chunk_size we use needs # to balance CPU-intensive string concatenation with accuracy # (eg. it's possible to fetch 1000 bytes greater than # max_template_size with a chunk_size of 1000). reader = resp.iter_content(chunk_size=1000) result = "" for chunk in reader: result += chunk if len(result) > cfg.CONF.max_template_size: raise IOError("Template exceeds maximum allowed size (%s " "bytes)" % cfg.CONF.max_template_size) return result except exceptions.RequestException as ex: raise IOError(_('Failed to retrieve template: %s') % str(ex)) heat-2014.1.5/heat/common/crypt.py0000664000567000056700000000425712540642614017765 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. import base64 from Crypto.Cipher import AES from oslo.config import cfg from heat.openstack.common.crypto import utils from heat.openstack.common import log as logging auth_opts = [ cfg.StrOpt('auth_encryption_key', default='notgood but just long enough i think', help="Encryption key used for authentication info in database.") ] cfg.CONF.register_opts(auth_opts) logger = logging.getLogger(__name__) def encrypt(auth_info): if auth_info is None: return None, None sym = utils.SymmetricCrypto() res = sym.encrypt(cfg.CONF.auth_encryption_key[:32], auth_info, b64encode=True) return 'oslo_decrypt_v1', res def oslo_decrypt_v1(auth_info): if auth_info is None: return None sym = utils.SymmetricCrypto() return sym.decrypt(cfg.CONF.auth_encryption_key[:32], auth_info, b64decode=True) def heat_decrypt(auth_info): """Decrypt function for data that has been encrypted using an older version of Heat. Note: the encrypt function returns the function that is needed to decrypt the data. The database then stores this. When the data is then retrieved (potentially by a later version of Heat) the decrypt function must still exist. So whilst it my seem that this function is not referenced, it will be referenced from the database. """ if auth_info is None: return None auth = base64.b64decode(auth_info) iv = auth[:AES.block_size] cipher = AES.new(cfg.CONF.auth_encryption_key[:32], AES.MODE_CFB, iv) res = cipher.decrypt(auth[AES.block_size:]) return res heat-2014.1.5/heat/common/short_id.py0000664000567000056700000000360612540642614020434 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. ''' Utilities for creating short ID strings based on a random UUID. The IDs each comprise 12 (lower-case) alphanumeric characters. ''' import base64 import uuid from six.moves import xrange def _to_byte_string(value, num_bits): ''' Convert an integer to a big-endian string of bytes, with any padding required added at the end (i.e. after the least-significant bit). ''' shifts = xrange(num_bits - 8, -8, -8) byte_at = lambda off: (value >> off if off >= 0 else value << -off) & 0xff return ''.join(chr(byte_at(offset)) for offset in shifts) def get_id(source_uuid): ''' Derive a short (12 character) id from a random UUID. The supplied UUID must be a version 4 UUID object. ''' if isinstance(source_uuid, basestring): source_uuid = uuid.UUID(source_uuid) if source_uuid.version != 4: raise ValueError(_('Invalid UUID version (%d)') % source_uuid.version) # The "time" field of a v4 UUID contains 60 random bits # (see RFC4122, Section 4.4) random_bytes = _to_byte_string(source_uuid.time, 60) # The first 12 bytes (= 60 bits) of base32-encoded output is our data encoded = base64.b32encode(random_bytes)[:12] return encoded.lower() def generate_id(): ''' Generate a short (12 character), random id. ''' return get_id(uuid.uuid4()) heat-2014.1.5/heat/common/custom_backend_auth.py0000664000567000056700000000415212540642614022620 0ustar jenkinsjenkins00000000000000 # Copyright (C) 2012, Red Hat, Inc. # # 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. """ Middleware for authenticating against custom backends. """ import logging from heat.openstack.common.gettextutils import _ from heat.openstack.common import local from heat.rpc import client as rpc_client import webob.exc LOG = logging.getLogger(__name__) class AuthProtocol(object): def __init__(self, app, conf): self.conf = conf self.app = app self.rpc_client = rpc_client.EngineClient() def __call__(self, env, start_response): """ Handle incoming request. Authenticate send downstream on success. Reject request if we can't authenticate. """ LOG.debug(_('Authenticating user token')) context = local.store.context authenticated = self.rpc_client.authenticated_to_backend(context) if authenticated: return self.app(env, start_response) else: return self._reject_request(env, start_response) def _reject_request(self, env, start_response): """ Redirect client to auth server. :param env: wsgi request environment :param start_response: wsgi response callback :returns HTTPUnauthorized http response """ resp = webob.exc.HTTPUnauthorized(_("Backend authentication failed"), []) return resp(env, start_response) def filter_factory(global_conf, **local_conf): conf = global_conf.copy() conf.update(local_conf) def auth_filter(app): return AuthProtocol(app, conf) return auth_filter heat-2014.1.5/heat/common/identifier.py0000664000567000056700000002026212540642614020740 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. import collections import re from heat.openstack.common.py3kcompat import urlutils from heat.openstack.common import strutils class HeatIdentifier(collections.Mapping): FIELDS = ( TENANT, STACK_NAME, STACK_ID, PATH ) = ( 'tenant', 'stack_name', 'stack_id', 'path' ) path_re = re.compile(r'stacks/([^/]+)/([^/]+)(.*)') def __init__(self, tenant, stack_name, stack_id, path=''): ''' Initialise a HeatIdentifier from a Tenant ID, Stack name, Stack ID and optional path. If a path is supplied and it does not begin with "/", a "/" will be prepended. ''' if path and not path.startswith('/'): path = '/' + path if '/' in stack_name: raise ValueError(_('Stack name may not contain "/"')) self.identity = { self.TENANT: tenant, self.STACK_NAME: stack_name, self.STACK_ID: str(stack_id), self.PATH: path, } @classmethod def from_arn(cls, arn): ''' Return a new HeatIdentifier generated by parsing the supplied ARN. ''' fields = arn.split(':') if len(fields) < 6 or fields[0].lower() != 'arn': raise ValueError(_('"%s" is not a valid ARN') % arn) id_fragment = ':'.join(fields[5:]) path = cls.path_re.match(id_fragment) if fields[1] != 'openstack' or fields[2] != 'heat' or not path: raise ValueError(_('"%s" is not a valid Heat ARN') % arn) return cls(urlutils.unquote(fields[4]), urlutils.unquote(path.group(1)), urlutils.unquote(path.group(2)), urlutils.unquote(path.group(3))) @classmethod def from_arn_url(cls, url): ''' Return a new HeatIdentifier generated by parsing the supplied URL The URL is expected to contain a valid arn as part of the path ''' # Sanity check the URL urlp = urlutils.urlparse(url) if (urlp.scheme not in ('http', 'https') or not urlp.netloc or not urlp.path): raise ValueError(_('"%s" is not a valid URL') % url) # Remove any query-string and extract the ARN arn_url_prefix = '/arn%3Aopenstack%3Aheat%3A%3A' match = re.search(arn_url_prefix, urlp.path, re.IGNORECASE) if match is None: raise ValueError(_('"%s" is not a valid ARN URL') % url) # the +1 is to skip the leading / url_arn = urlp.path[match.start() + 1:] arn = urlutils.unquote(url_arn) return cls.from_arn(arn) def arn(self): ''' Return an ARN of the form: arn:openstack:heat:::stacks// ''' return 'arn:openstack:heat::%s:%s' % (urlutils.quote(self.tenant, ''), self._tenant_path()) def arn_url_path(self): ''' Return an ARN quoted correctly for use in a URL ''' return '/' + urlutils.quote(self.arn(), '') def url_path(self): ''' Return a URL-encoded path segment of a URL in the form: /stacks// ''' return '/'.join((urlutils.quote(self.tenant, ''), self._tenant_path())) def _tenant_path(self): ''' Return a URL-encoded path segment of a URL within a particular tenant, in the form: stacks// ''' return 'stacks/%s%s' % (self.stack_path(), urlutils.quote(strutils.safe_encode( self.path))) def stack_path(self): ''' Return a URL-encoded path segment of a URL, in the form: / ''' return '%s/%s' % (urlutils.quote(self.stack_name, ''), urlutils.quote(self.stack_id, '')) def _path_components(self): '''Return a list of the path components.''' return self.path.lstrip('/').split('/') def __getattr__(self, attr): ''' Return one of the components of the identity when accessed as an attribute. ''' if attr not in self.FIELDS: raise AttributeError(_('Unknown attribute "%s"') % attr) return self.identity[attr] def __getitem__(self, key): '''Return one of the components of the identity.''' if key not in self.FIELDS: raise KeyError(_('Unknown attribute "%s"') % key) return self.identity[key] def __len__(self): '''Return the number of components in an identity.''' return len(self.FIELDS) def __contains__(self, key): return key in self.FIELDS def __iter__(self): return iter(self.FIELDS) def __repr__(self): return repr(dict(self)) class ResourceIdentifier(HeatIdentifier): '''An identifier for a resource.''' RESOURCE_NAME = 'resource_name' def __init__(self, tenant, stack_name, stack_id, path, resource_name=None): ''' Return a new Resource identifier based on the identifier components of the owning stack and the resource name. ''' if resource_name is not None: if '/' in resource_name: raise ValueError(_('Resource name may not contain "/"')) path = '/'.join([path.rstrip('/'), 'resources', resource_name]) super(ResourceIdentifier, self).__init__(tenant, stack_name, stack_id, path) def __getattr__(self, attr): ''' Return one of the components of the identity when accessed as an attribute. ''' if attr == self.RESOURCE_NAME: return self._path_components()[-1] return HeatIdentifier.__getattr__(self, attr) def stack(self): ''' Return a HeatIdentifier for the owning stack ''' return HeatIdentifier(self.tenant, self.stack_name, self.stack_id, '/'.join(self._path_components()[:-2])) class EventIdentifier(HeatIdentifier): '''An identifier for an event.''' (RESOURCE_NAME, EVENT_ID) = (ResourceIdentifier.RESOURCE_NAME, 'event_id') def __init__(self, tenant, stack_name, stack_id, path, event_id=None): ''' Return a new Event identifier based on the identifier components of the associated resource and the event ID. ''' if event_id is not None: path = '/'.join([path.rstrip('/'), 'events', event_id]) super(EventIdentifier, self).__init__(tenant, stack_name, stack_id, path) def __getattr__(self, attr): ''' Return one of the components of the identity when accessed as an attribute. ''' if attr == self.RESOURCE_NAME: return getattr(self.resource(), attr) if attr == self.EVENT_ID: return self._path_components()[-1] return HeatIdentifier.__getattr__(self, attr) def resource(self): ''' Return a HeatIdentifier for the owning resource ''' return ResourceIdentifier(self.tenant, self.stack_name, self.stack_id, '/'.join(self._path_components()[:-2])) def stack(self): ''' Return a HeatIdentifier for the owning stack ''' return self.resource().stack() heat-2014.1.5/heat/common/exception.py0000664000567000056700000002447412540642614020625 0ustar jenkinsjenkins00000000000000 # Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # # 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 exception subclasses""" import functools import sys from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils _FATAL_EXCEPTION_FORMAT_ERRORS = False logger = logging.getLogger(__name__) class RedirectException(Exception): def __init__(self, url): self.url = urlutils.urlparse(url) class KeystoneError(Exception): def __init__(self, code, message): self.code = code self.message = message def __str__(self): return "Code: %s, message: %s" % (self.code, self.message) def wrap_exception(notifier=None, publisher_id=None, event_type=None, level=None): """This decorator wraps a method to catch any exceptions that may get thrown. It logs the exception as well as optionally sending it to the notification system. """ # TODO(sandy): Find a way to import nova.notifier.api so we don't have # to pass it in as a parameter. Otherwise we get a cyclic import of # nova.notifier.api -> nova.utils -> nova.exception :( # TODO(johannes): Also, it would be nice to use # utils.save_and_reraise_exception() without an import loop def inner(f): def wrapped(*args, **kw): try: return f(*args, **kw) except Exception as e: # Save exception since it can be clobbered during processing # below before we can re-raise exc_info = sys.exc_info() if notifier: payload = dict(args=args, exception=e) payload.update(kw) # Use a temp vars so we don't shadow # our outer definitions. temp_level = level if not temp_level: temp_level = notifier.ERROR temp_type = event_type if not temp_type: # If f has multiple decorators, they must use # functools.wraps to ensure the name is # propagated. temp_type = f.__name__ notifier.notify(publisher_id, temp_type, temp_level, payload) # re-raise original exception since it may have been clobbered raise exc_info[0], exc_info[1], exc_info[2] return functools.wraps(f)(wrapped) return inner class HeatException(Exception): """Base Heat Exception To correctly use this class, inherit from it and define a 'msg_fmt' property. That msg_fmt will get printf'd with the keyword arguments provided to the constructor. """ message = _("An unknown exception occurred.") def __init__(self, **kwargs): self.kwargs = kwargs try: self.message = self.msg_fmt % kwargs except KeyError: exc_info = sys.exc_info() #kwargs doesn't match a variable in the message #log the issue and the kwargs logger.exception(_('Exception in string format operation')) for name, value in kwargs.iteritems(): logger.error("%s: %s" % (name, value)) if _FATAL_EXCEPTION_FORMAT_ERRORS: raise exc_info[0], exc_info[1], exc_info[2] def __str__(self): return str(self.message) def __unicode__(self): return unicode(self.message) class MissingCredentialError(HeatException): msg_fmt = _("Missing required credential: %(required)s") class BadAuthStrategy(HeatException): msg_fmt = _("Incorrect auth strategy, expected \"%(expected)s\" but " "received \"%(received)s\"") class AuthBadRequest(HeatException): msg_fmt = _("Connect error/bad request to Auth service at URL %(url)s.") class AuthUrlNotFound(HeatException): msg_fmt = _("Auth service at URL %(url)s not found.") class AuthorizationFailure(HeatException): msg_fmt = _("Authorization failed.") class NotAuthenticated(HeatException): msg_fmt = _("You are not authenticated.") class Forbidden(HeatException): msg_fmt = _("You are not authorized to complete this action.") #NOTE(bcwaldon): here for backwards-compatability, need to deprecate. class NotAuthorized(Forbidden): msg_fmt = _("You are not authorized to complete this action.") class Invalid(HeatException): msg_fmt = _("Data supplied was not valid: %(reason)s") class AuthorizationRedirect(HeatException): msg_fmt = _("Redirecting to %(uri)s for authorization.") class RequestUriTooLong(HeatException): msg_fmt = _("The URI was too long.") class MaxRedirectsExceeded(HeatException): msg_fmt = _("Maximum redirects (%(redirects)s) was exceeded.") class InvalidRedirect(HeatException): msg_fmt = _("Received invalid HTTP redirect.") class RegionAmbiguity(HeatException): msg_fmt = _("Multiple 'image' service matches for region %(region)s. This " "generally means that a region is required and you have not " "supplied one.") class UserParameterMissing(HeatException): msg_fmt = _("The Parameter (%(key)s) was not provided.") class UnknownUserParameter(HeatException): msg_fmt = _("The Parameter (%(key)s) was not defined in template.") class InvalidTemplateVersion(HeatException): msg_fmt = _("The template version is invalid: %(explanation)s") class InvalidTemplateSection(HeatException): msg_fmt = _("The template section is invalid: %(section)s") class InvalidTemplateParameter(HeatException): msg_fmt = _("The Parameter (%(key)s) has no attributes.") class InvalidTemplateAttribute(HeatException): msg_fmt = _("The Referenced Attribute (%(resource)s %(key)s)" " is incorrect.") class InvalidTemplateReference(HeatException): msg_fmt = _("The specified reference \"%(resource)s\" (in %(key)s)" " is incorrect.") class UserKeyPairMissing(HeatException): msg_fmt = _("The Key (%(key_name)s) could not be found.") class FlavorMissing(HeatException): msg_fmt = _("The Flavor ID (%(flavor_id)s) could not be found.") class ImageNotFound(HeatException): msg_fmt = _("The Image (%(image_name)s) could not be found.") class PhysicalResourceNameAmbiguity(HeatException): msg_fmt = _( "Multiple physical resources were found with name (%(name)s).") class InvalidTenant(HeatException): msg_fmt = _("Searching Tenant %(target)s " "from Tenant %(actual)s forbidden.") class StackNotFound(HeatException): msg_fmt = _("The Stack (%(stack_name)s) could not be found.") class StackExists(HeatException): msg_fmt = _("The Stack (%(stack_name)s) already exists.") class StackValidationFailed(HeatException): msg_fmt = _("%(message)s") class ResourceNotFound(HeatException): msg_fmt = _("The Resource (%(resource_name)s) could not be found " "in Stack %(stack_name)s.") class ResourceTypeNotFound(HeatException): msg_fmt = _("The Resource Type (%(type_name)s) could not be found.") class ResourceNotAvailable(HeatException): msg_fmt = _("The Resource (%(resource_name)s) is not available.") class PhysicalResourceNotFound(HeatException): msg_fmt = _("The Resource (%(resource_id)s) could not be found.") class WatchRuleNotFound(HeatException): msg_fmt = _("The Watch Rule (%(watch_name)s) could not be found.") class ResourceFailure(HeatException): msg_fmt = _("%(exc_type)s: %(message)s") def __init__(self, exception, resource, action=None): if isinstance(exception, ResourceFailure): exception = getattr(exception, 'exc', exception) self.exc = exception self.resource = resource self.action = action exc_type = type(exception).__name__ super(ResourceFailure, self).__init__(exc_type=exc_type, message=str(exception)) class NotSupported(HeatException): msg_fmt = _("%(feature)s is not supported.") class ResourcePropertyConflict(HeatException): msg_fmt = _('Cannot define the following properties at the same time: %s.') def __init__(self, *args): self.msg_fmt = self.msg_fmt % ", ".join(args) super(ResourcePropertyConflict, self).__init__() class HTTPExceptionDisguise(Exception): """Disguises HTTP exceptions so they can be handled by the webob fault application in the wsgi pipeline. """ def __init__(self, exception): self.exc = exception self.tb = sys.exc_info()[2] class EgressRuleNotAllowed(HeatException): msg_fmt = _("Egress rules are only allowed when " "Neutron is used and the 'VpcId' property is set.") class Error(HeatException): def __init__(self, msg_fmt): self.msg_fmt = msg_fmt super(Error, self).__init__() class NotFound(HeatException): def __init__(self, msg_fmt=_('Not found')): self.msg_fmt = msg_fmt super(NotFound, self).__init__() class InvalidContentType(HeatException): msg_fmt = _("Invalid content type %(content_type)s") class RequestLimitExceeded(HeatException): msg_fmt = _('Request limit exceeded: %(message)s') class StackResourceLimitExceeded(HeatException): msg_fmt = _('Maximum resources per stack exceeded.') class ActionInProgress(HeatException): msg_fmt = _("Stack %(stack_name)s already has an action (%(action)s) " "in progress.") class SoftwareConfigMissing(HeatException): msg_fmt = _("The config (%(software_config_id)s) could not be found.") class StopActionFailed(HeatException): msg_fmt = _("Failed to stop stack (%(stack_name)s) on other engine " "(%(engine_id)s)") heat-2014.1.5/heat/common/policy.py0000664000567000056700000000766312540642614020127 0ustar jenkinsjenkins00000000000000 # Copyright (c) 2011 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. # Based on glance/api/policy.py """Policy Engine For Heat""" from oslo.config import cfg from heat.common import exception import heat.openstack.common.log as logging from heat.openstack.common import policy logger = logging.getLogger(__name__) CONF = cfg.CONF DEFAULT_RULES = { 'default': policy.FalseCheck(), } class Enforcer(object): """Responsible for loading and enforcing rules.""" def __init__(self, scope='heat', exc=exception.Forbidden, default_rule=DEFAULT_RULES['default']): self.scope = scope self.exc = exc self.default_rule = default_rule self.enforcer = policy.Enforcer(default_rule=default_rule) def set_rules(self, rules, overwrite=True): """Create a new Rules object based on the provided dict of rules.""" rules_obj = policy.Rules(rules, self.default_rule) self.enforcer.set_rules(rules_obj, overwrite) def load_rules(self, force_reload=False): """Set the rules found in the json file on disk.""" self.enforcer.load_rules(force_reload) def _check(self, context, rule, target, exc, *args, **kwargs): """Verifies that the action is valid on the target in this context. :param context: Heat request context :param rule: String representing the action to be checked :param target: Dictionary representing the object of the action. :raises: self.exc (defaults to heat.common.exception.Forbidden) :returns: A non-False value if access is allowed. """ do_raise = False if not exc else True credentials = { 'roles': context.roles, 'user': context.username, 'tenant': context.tenant, } return self.enforcer.enforce(rule, target, credentials, do_raise, exc=exc, *args, **kwargs) def enforce(self, context, action, scope=None, target=None): """Verifies that the action is valid on the target in this context. :param context: Heat request context :param action: String representing the action to be checked :param target: Dictionary representing the object of the action. :raises: self.exc (defaults to heat.common.exception.Forbidden) :returns: A non-False value if access is allowed. """ _action = '%s:%s' % (scope or self.scope, action) _target = target or {} return self._check(context, _action, _target, self.exc, action=action) def check(self, context, action, target): """Verifies that the action is valid on the target in this context. :param context: Heat request context :param action: String representing the action to be checked :param target: Dictionary representing the object of the action. :returns: A non-False value if access is allowed. """ return self._check(context, action, target) def check_is_admin(self, context): """Whether or not roles contains 'admin' role according to policy.json :param context: Heat request context :returns: A non-False value if the user is admin according to policy """ return self._check(context, 'context_is_admin', target={}, exc=None) def clear(self): self.enforcer.clear() heat-2014.1.5/heat/common/auth_url.py0000664000567000056700000000447512540642614020451 0ustar jenkinsjenkins00000000000000# Copyright 2013 OpenStack Foundation # # 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. from oslo.config import cfg from webob.exc import HTTPBadRequest from webob.exc import HTTPUnauthorized from heat.common import wsgi from heat.openstack.common import importutils class AuthUrlFilter(wsgi.Middleware): def __init__(self, app, conf): super(AuthUrlFilter, self).__init__(app) self.conf = conf self.auth_url = self._get_auth_url() def _get_auth_url(self): if 'auth_uri' in self.conf: return self.conf['auth_uri'] else: # Import auth_token to have keystone_authtoken settings setup. auth_token_module = 'keystoneclient.middleware.auth_token' importutils.import_module(auth_token_module) return cfg.CONF.keystone_authtoken.auth_uri def _validate_auth_url(self, auth_url): """Validate auth_url to ensure it can be used.""" if not auth_url: raise HTTPBadRequest(_('Request missing required header ' 'X-Auth-Url')) allowed = cfg.CONF.auth_password.allowed_auth_uris if auth_url not in allowed: raise HTTPUnauthorized(_('Header X-Auth-Url "%s" not an allowed ' 'endpoint') % auth_url) return True def process_request(self, req): auth_url = self.auth_url if cfg.CONF.auth_password.multi_cloud: auth_url = req.headers.get('X-Auth-Url') self._validate_auth_url(auth_url) req.headers['X-Auth-Url'] = auth_url return None def filter_factory(global_conf, **local_conf): conf = global_conf.copy() conf.update(local_conf) def auth_url_filter(app): return AuthUrlFilter(app, conf) return auth_url_filter heat-2014.1.5/heat/common/heat_keystoneclient.py0000664000567000056700000006216712540642614022671 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. from collections import namedtuple import json import uuid import keystoneclient.exceptions as kc_exception from keystoneclient.v3 import client as kc_v3 from oslo.config import cfg from heat.common import context from heat.common import exception from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import log as logging logger = logging.getLogger('heat.common.keystoneclient') AccessKey = namedtuple('AccessKey', ['id', 'access', 'secret']) _default_keystone_backend = "heat.common.heat_keystoneclient.KeystoneClientV3" keystone_opts = [ cfg.StrOpt('keystone_backend', default=_default_keystone_backend, help="Fully qualified class name to use as a keystone backend.") ] cfg.CONF.register_opts(keystone_opts) class KeystoneClientV3(object): """ Wrap keystone client so we can encapsulate logic used in resources Note this is intended to be initialized from a resource on a per-session basis, so the session context is passed in on initialization Also note that a copy of this is created every resource as self.keystone() via the code in engine/client.py, so there should not be any need to directly instantiate instances of this class inside resources themselves """ def __init__(self, context): # If a trust_id is specified in the context, we immediately # authenticate so we can populate the context with a trust token # otherwise, we delay client authentication until needed to avoid # unnecessary calls to keystone. # # Note that when you obtain a token using a trust, it cannot be # used to reauthenticate and get another token, so we have to # get a new trust-token even if context.auth_token is set. # # - context.auth_url is expected to contain a versioned keystone # path, we will work with either a v2.0 or v3 path self.context = context self._client = None self._admin_client = None self._domain_admin_client = None if self.context.auth_url: self.v3_endpoint = self.context.auth_url.replace('v2.0', 'v3') else: # Import auth_token to have keystone_authtoken settings setup. importutils.import_module('keystoneclient.middleware.auth_token') self.v3_endpoint = cfg.CONF.keystone_authtoken.auth_uri.replace( 'v2.0', 'v3') if self.context.trust_id: # Create a client with the specified trust_id, this # populates self.context.auth_token with a trust-scoped token self._client = self._v3_client_init() # The stack domain user ID should be set in heat.conf # It can be created via python-openstackclient # openstack --os-identity-api-version=3 domain create heat # If the domain is specified, then you must specify a domain # admin user. If no domain is specified, we fall back to # legacy behavior with warnings. self.stack_domain_id = cfg.CONF.stack_user_domain self.domain_admin_user = cfg.CONF.stack_domain_admin self.domain_admin_password = cfg.CONF.stack_domain_admin_password if self.stack_domain_id: if not (self.domain_admin_user and self.domain_admin_password): raise exception.Error(_('heat.conf misconfigured, cannot ' 'specify stack_user_domain without' ' stack_domain_admin and' ' stack_domain_admin_password')) else: logger.warning(_('stack_user_domain ID not set in heat.conf ' 'falling back to using default')) logger.debug(_('Using stack domain %s') % self.stack_domain_id) @property def client(self): if not self._client: # Create connection to v3 API self._client = self._v3_client_init() return self._client @property def admin_client(self): if not self._admin_client: # Create admin client connection to v3 API admin_creds = self._service_admin_creds() admin_creds.update(self._ssl_options()) c = kc_v3.Client(**admin_creds) if c.authenticate(): self._admin_client = c else: logger.error("Admin client authentication failed") raise exception.AuthorizationFailure() return self._admin_client @property def domain_admin_client(self): if not self._domain_admin_client: # Create domain admin client connection to v3 API admin_creds = self._domain_admin_creds() admin_creds.update(self._ssl_options()) c = kc_v3.Client(**admin_creds) # Note we must specify the domain when getting the token # as only a domain scoped token can create projects in the domain if c.authenticate(domain_id=self.stack_domain_id): self._domain_admin_client = c else: logger.error("Domain admin client authentication failed") raise exception.AuthorizationFailure() return self._domain_admin_client def _v3_client_init(self): kwargs = { 'auth_url': self.v3_endpoint, 'endpoint': self.v3_endpoint } # Note try trust_id first, as we can't reuse auth_token in that case if self.context.trust_id is not None: # We got a trust_id, so we use the admin credentials # to authenticate with the trust_id so we can use the # trust impersonating the trustor user. kwargs.update(self._service_admin_creds()) kwargs['trust_id'] = self.context.trust_id kwargs.pop('project_name') elif self.context.auth_token is not None: kwargs['token'] = self.context.auth_token kwargs['project_id'] = self.context.tenant_id elif self.context.password is not None: kwargs['username'] = self.context.username kwargs['password'] = self.context.password kwargs['project_id'] = self.context.tenant_id else: logger.error(_("Keystone v3 API connection failed, no password " "trust or auth_token!")) raise exception.AuthorizationFailure() kwargs.update(self._ssl_options()) client = kc_v3.Client(**kwargs) client.authenticate() # If we are authenticating with a trust set the context auth_token # with the trust scoped token if 'trust_id' in kwargs: # Sanity check if not client.auth_ref.trust_scoped: logger.error(_("trust token re-scoping failed!")) raise exception.AuthorizationFailure() # All OK so update the context with the token self.context.auth_token = client.auth_ref.auth_token self.context.auth_url = kwargs.get('auth_url') # Sanity check that impersonation is effective if self.context.trustor_user_id != client.auth_ref.user_id: logger.error("Trust impersonation failed") raise exception.AuthorizationFailure() return client def _service_admin_creds(self): # Import auth_token to have keystone_authtoken settings setup. importutils.import_module('keystoneclient.middleware.auth_token') creds = { 'username': cfg.CONF.keystone_authtoken.admin_user, 'password': cfg.CONF.keystone_authtoken.admin_password, 'auth_url': self.v3_endpoint, 'endpoint': self.v3_endpoint, 'project_name': cfg.CONF.keystone_authtoken.admin_tenant_name} return creds def _domain_admin_creds(self): creds = { 'username': self.domain_admin_user, 'user_domain_id': self.stack_domain_id, 'password': self.domain_admin_password, 'auth_url': self.v3_endpoint, 'endpoint': self.v3_endpoint} return creds def _ssl_options(self): opts = {'cacert': self._get_client_option('ca_file'), 'insecure': self._get_client_option('insecure'), 'cert': self._get_client_option('cert_file'), 'key': self._get_client_option('key_file')} return opts def _get_client_option(self, option): try: cfg.CONF.import_opt(option, 'heat.common.config', group='clients_keystone') return getattr(cfg.CONF.clients_keystone, option) except (cfg.NoSuchGroupError, cfg.NoSuchOptError): cfg.CONF.import_opt(option, 'heat.common.config', group='clients') return getattr(cfg.CONF.clients, option) def create_trust_context(self): """ Create a trust using the trustor identity in the current context, with the trustee as the heat service user and return a context containing the new trust_id. If the current context already contains a trust_id, we do nothing and return the current context. """ if self.context.trust_id: return self.context # We need the service admin user ID (not name), as the trustor user # can't lookup the ID in keystoneclient unless they're admin # workaround this by getting the user_id from admin_client trustee_user_id = self.admin_client.auth_ref.user_id trustor_user_id = self.client.auth_ref.user_id trustor_project_id = self.client.auth_ref.project_id roles = cfg.CONF.trusts_delegated_roles trust = self.client.trusts.create(trustor_user=trustor_user_id, trustee_user=trustee_user_id, project=trustor_project_id, impersonation=True, role_names=roles) trust_context = context.RequestContext.from_dict( self.context.to_dict()) trust_context.trust_id = trust.id trust_context.trustor_user_id = trustor_user_id return trust_context def delete_trust(self, trust_id): """ Delete the specified trust. """ try: self.client.trusts.delete(trust_id) except kc_exception.NotFound: pass def _get_username(self, username): if(len(username) > 64): logger.warning(_("Truncating the username %s to the last 64 " "characters.") % username) #get the last 64 characters of the username return username[-64:] def _get_stack_user_role(self, roles_list): # FIXME(shardy): The currently released v3 keystoneclient doesn't # support filtering the results, so we have to do it locally, # update when a new keystoneclient release happens containing # the extensible-crud-manager-operations patch stack_user_role = [r for r in roles_list if r.name == cfg.CONF.heat_stack_user_role] if len(stack_user_role) == 1: return stack_user_role[0].id def create_stack_user(self, username, password=''): """ Create a user defined as part of a stack, either via template or created internally by a resource. This user will be added to the heat_stack_user_role as defined in the config Returns the keystone ID of the resulting user """ # FIXME(shardy): There's duplicated logic between here and # create_stack_domain user, but this function is expected to # be removed after the transition of all resources to domain # users has been completed roles_list = self.client.roles.list() role_id = self._get_stack_user_role(roles_list) if role_id: # Create the user user = self.client.users.create( name=self._get_username(username), password=password, default_project=self.context.tenant_id) # Add user to heat_stack_user_role logger.debug(_("Adding user %(user)s to role %(role)s") % { 'user': user.id, 'role': role_id}) self.client.roles.grant(role=role_id, user=user.id, project=self.context.tenant_id) else: logger.error(_("Failed to add user %(user)s to role %(role)s, " "check role exists!") % { 'user': username, 'role': cfg.CONF.heat_stack_user_role}) raise exception.Error(_("Can't find role %s") % cfg.CONF.heat_stack_user_role) return user.id def create_stack_domain_user(self, username, project_id, password=None): """ Create a user defined as part of a stack, either via template or created internally by a resource. This user will be added to the heat_stack_user_role as defined in the config, and created in the specified project (which is expected to be in the stack_domain. Returns the keystone ID of the resulting user """ if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain user create, ' 'configure domain in heat.conf')) return self.create_stack_user(username=username, password=password) # We add the new user to a special keystone role # This role is designed to allow easier differentiation of the # heat-generated "stack users" which will generally have credentials # deployed on an instance (hence are implicitly untrusted) roles_list = self.domain_admin_client.roles.list() role_id = self._get_stack_user_role(roles_list) if role_id: # Create user user = self.domain_admin_client.users.create( name=self._get_username(username), password=password, default_project=project_id, domain=self.stack_domain_id) # Add to stack user role logger.debug(_("Adding user %(user)s to role %(role)s") % { 'user': user.id, 'role': role_id}) self.domain_admin_client.roles.grant(role=role_id, user=user.id, project=project_id) else: logger.error(_("Failed to add user %(user)s to role %(role)s, " "check role exists!") % {'user': username, 'role': cfg.CONF.heat_stack_user_role}) raise exception.Error(_("Can't find role %s") % cfg.CONF.heat_stack_user_role) return user.id def _check_stack_domain_user(self, user_id, project_id, action): # Sanity check that domain/project is correct user = self.domain_admin_client.users.get(user_id) if user.domain_id != self.stack_domain_id: raise ValueError(_('User %s in invalid domain') % action) if user.default_project_id != project_id: raise ValueError(_('User %s in invalid project') % action) def delete_stack_domain_user(self, user_id, project_id): if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain user delete, ' 'configure domain in heat.conf')) return self.delete_stack_user(user_id) try: self._check_stack_domain_user(user_id, project_id, 'delete') self.domain_admin_client.users.delete(user_id) except kc_exception.NotFound: pass def delete_stack_user(self, user_id): try: self.client.users.delete(user=user_id) except kc_exception.NotFound: pass def create_stack_domain_project(self, stack_id): '''Creates a project in the heat stack-user domain.''' if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain project, ' 'configure domain in heat.conf')) return self.context.tenant_id # Note we use the tenant ID not name to ensure uniqueness in a multi- # domain environment (where the tenant name may not be globally unique) project_name = ('%s-%s' % (self.context.tenant_id, stack_id))[:64] desc = "Heat stack user project" domain_project = self.domain_admin_client.projects.create( name=project_name, domain=self.stack_domain_id, description=desc) return domain_project.id def delete_stack_domain_project(self, project_id): if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain project, ' 'configure domain in heat.conf')) return # If stacks are created before configuring the heat domain, they # exist in the default domain, in the user's project, which we # do *not* want to delete! However, if the keystone v3cloudsample # policy is used, it's possible that we'll get Forbidden when trying # to get the project, so again we should do nothing try: project = self.domain_admin_client.projects.get(project=project_id) except kc_exception.Forbidden: logger.warning(_('Unable to get details for project %s, ' 'not deleting') % project_id) return if project.domain_id != self.stack_domain_id: logger.warning(_('Not deleting non heat-domain project')) return try: project.delete() except kc_exception.NotFound: pass def _find_ec2_keypair(self, access, user_id=None): '''Lookup an ec2 keypair by access ID.''' # FIXME(shardy): add filtering for user_id when keystoneclient # extensible-crud-manager-operations bp lands credentials = self.client.credentials.list() for cr in credentials: ec2_creds = json.loads(cr.blob) if ec2_creds.get('access') == access: return AccessKey(id=cr.id, access=ec2_creds['access'], secret=ec2_creds['secret']) def delete_ec2_keypair(self, credential_id=None, access=None, user_id=None): '''Delete credential containing ec2 keypair.''' if credential_id: try: self.client.credentials.delete(credential_id) except kc_exception.NotFound: pass elif access: cred = self._find_ec2_keypair(access=access, user_id=user_id) if cred: self.client.credentials.delete(cred.id) else: raise ValueError("Must specify either credential_id or access") def get_ec2_keypair(self, credential_id=None, access=None, user_id=None): '''Get an ec2 keypair via v3/credentials, by id or access.''' # Note v3/credentials does not support filtering by access # because it's stored in the credential blob, so we expect # all resources to pass credential_id except where backwards # compatibility is required (resource only has acccess stored) # then we'll have to to a brute-force lookup locally if credential_id: cred = self.client.credentials.get(credential_id) ec2_creds = json.loads(cred.blob) return AccessKey(id=cred.id, access=ec2_creds['access'], secret=ec2_creds['secret']) elif access: return self._find_ec2_keypair(access=access, user_id=user_id) else: raise ValueError("Must specify either credential_id or access") def create_ec2_keypair(self, user_id=None): user_id = user_id or self.client.auth_ref.user_id project_id = self.context.tenant_id data_blob = {'access': uuid.uuid4().hex, 'secret': uuid.uuid4().hex} ec2_creds = self.client.credentials.create( user=user_id, type='ec2', data=json.dumps(data_blob), project=project_id) # Return a AccessKey namedtuple for easier access to the blob contents # We return the id as the v3 api provides no way to filter by # access in the blob contents, so it will be much more efficient # if we manage credentials by ID instead return AccessKey(id=ec2_creds.id, access=data_blob['access'], secret=data_blob['secret']) def create_stack_domain_user_keypair(self, user_id, project_id): if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain keypair, ' 'configure domain in heat.conf')) return self.create_ec2_keypair(user_id) data_blob = {'access': uuid.uuid4().hex, 'secret': uuid.uuid4().hex} creds = self.domain_admin_client.credentials.create( user=user_id, type='ec2', data=json.dumps(data_blob), project=project_id) return AccessKey(id=creds.id, access=data_blob['access'], secret=data_blob['secret']) def delete_stack_domain_user_keypair(self, user_id, project_id, credential_id): if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain keypair, ' 'configure domain in heat.conf')) return self.delete_ec2_keypair(credential_id=credential_id) self._check_stack_domain_user(user_id, project_id, 'delete_keypair') try: self.domain_admin_client.credentials.delete(credential_id) except kc_exception.NotFound: pass def disable_stack_user(self, user_id): self.client.users.update(user=user_id, enabled=False) def enable_stack_user(self, user_id): self.client.users.update(user=user_id, enabled=True) def disable_stack_domain_user(self, user_id, project_id): if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain disable, ' 'configure domain in heat.conf')) return self.disable_stack_user(user_id) self._check_stack_domain_user(user_id, project_id, 'disable') self.domain_admin_client.users.update(user=user_id, enabled=False) def enable_stack_domain_user(self, user_id, project_id): if not self.stack_domain_id: # FIXME(shardy): Legacy fallback for folks using old heat.conf # files which lack domain configuration logger.warning(_('Falling back to legacy non-domain enable, ' 'configure domain in heat.conf')) return self.enable_stack_user(user_id) self._check_stack_domain_user(user_id, project_id, 'enable') self.domain_admin_client.users.update(user=user_id, enabled=True) def url_for(self, **kwargs): default_region_name = cfg.CONF.region_name_for_services kwargs.setdefault('region_name', default_region_name) return self.client.service_catalog.url_for(**kwargs) @property def auth_token(self): return self.client.auth_token class KeystoneClient(object): """ Delay choosing the backend client module until the client's class needs to be initialized. """ def __new__(cls, context): if cfg.CONF.keystone_backend == _default_keystone_backend: return KeystoneClientV3(context) else: return importutils.import_object( cfg.CONF.keystone_backend, context ) heat-2014.1.5/heat/common/wsgi.py0000664000567000056700000010344612540642614017575 0ustar jenkinsjenkins00000000000000 # Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2013 IBM Corp. # 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. """ Utility methods for working with WSGI servers """ import datetime import errno import json import logging import os import signal import sys import time import eventlet from eventlet.green import socket from eventlet.green import ssl import eventlet.greenio import eventlet.wsgi from lxml import etree from oslo.config import cfg from paste import deploy import routes import routes.middleware import webob.dec import webob.exc from heat.common import exception from heat.openstack.common import gettextutils from heat.openstack.common import importutils URL_LENGTH_LIMIT = 50000 api_opts = [ cfg.StrOpt('bind_host', default='0.0.0.0', help=_('Address to bind the server. Useful when ' 'selecting a particular network interface.'), deprecated_group='DEFAULT'), cfg.IntOpt('bind_port', default=8004, help=_('The port on which the server will listen.'), deprecated_group='DEFAULT'), cfg.IntOpt('backlog', default=4096, help=_("Number of backlog requests " "to configure the socket with."), deprecated_group='DEFAULT'), cfg.StrOpt('cert_file', default=None, help=_("Location of the SSL certificate file " "to use for SSL mode."), deprecated_group='DEFAULT'), cfg.StrOpt('key_file', default=None, help=_("Location of the SSL key file to use " "for enabling SSL mode."), deprecated_group='DEFAULT'), cfg.IntOpt('workers', default=0, help=_("Number of workers for Heat service."), deprecated_group='DEFAULT'), cfg.IntOpt('max_header_line', default=16384, help=_('Maximum line size of message headers to be accepted. ' 'max_header_line may need to be increased when using ' 'large tokens (typically those generated by the ' 'Keystone v3 API with big service catalogs).')), ] api_group = cfg.OptGroup('heat_api') cfg.CONF.register_group(api_group) cfg.CONF.register_opts(api_opts, group=api_group) api_cfn_opts = [ cfg.StrOpt('bind_host', default='0.0.0.0', help=_('Address to bind the server. Useful when ' 'selecting a particular network interface.'), deprecated_group='DEFAULT'), cfg.IntOpt('bind_port', default=8000, help=_('The port on which the server will listen.'), deprecated_group='DEFAULT'), cfg.IntOpt('backlog', default=4096, help=_("Number of backlog requests " "to configure the socket with."), deprecated_group='DEFAULT'), cfg.StrOpt('cert_file', default=None, help=_("Location of the SSL certificate file " "to use for SSL mode."), deprecated_group='DEFAULT'), cfg.StrOpt('key_file', default=None, help=_("Location of the SSL key file to use " "for enabling SSL mode."), deprecated_group='DEFAULT'), cfg.IntOpt('workers', default=0, help=_("Number of workers for Heat service."), deprecated_group='DEFAULT'), cfg.IntOpt('max_header_line', default=16384, help=_('Maximum line size of message headers to be accepted. ' 'max_header_line may need to be increased when using ' 'large tokens (typically those generated by the ' 'Keystone v3 API with big service catalogs).')), ] api_cfn_group = cfg.OptGroup('heat_api_cfn') cfg.CONF.register_group(api_cfn_group) cfg.CONF.register_opts(api_cfn_opts, group=api_cfn_group) api_cw_opts = [ cfg.StrOpt('bind_host', default='0.0.0.0', help=_('Address to bind the server. Useful when ' 'selecting a particular network interface.'), deprecated_group='DEFAULT'), cfg.IntOpt('bind_port', default=8003, help=_('The port on which the server will listen.'), deprecated_group='DEFAULT'), cfg.IntOpt('backlog', default=4096, help=_("Number of backlog requests " "to configure the socket with."), deprecated_group='DEFAULT'), cfg.StrOpt('cert_file', default=None, help=_("Location of the SSL certificate file " "to use for SSL mode."), deprecated_group='DEFAULT'), cfg.StrOpt('key_file', default=None, help=_("Location of the SSL key file to use " "for enabling SSL mode."), deprecated_group='DEFAULT'), cfg.IntOpt('workers', default=0, help=_("Number of workers for Heat service."), deprecated_group='DEFAULT'), cfg.IntOpt('max_header_line', default=16384, help=_('Maximum line size of message headers to be accepted. ' 'max_header_line may need to be increased when using ' 'large tokens (typically those generated by the ' 'Keystone v3 API with big service catalogs.)')), ] api_cw_group = cfg.OptGroup('heat_api_cloudwatch') cfg.CONF.register_group(api_cw_group) cfg.CONF.register_opts(api_cw_opts, group=api_cw_group) cfg.CONF.import_opt('debug', 'heat.openstack.common.log') cfg.CONF.import_opt('verbose', 'heat.openstack.common.log') json_size_opt = cfg.IntOpt('max_json_body_size', default=1048576, help='Maximum raw byte size of JSON request body.' ' Should be larger than max_template_size.') cfg.CONF.register_opt(json_size_opt) class WritableLogger(object): """A thin wrapper that responds to `write` and logs.""" def __init__(self, logger, level=logging.DEBUG): self.logger = logger self.level = level def write(self, msg): self.logger.log(self.level, msg.strip("\n")) def get_bind_addr(conf, default_port=None): """Return the host and port to bind to.""" return (conf.bind_host, conf.bind_port or default_port) def get_socket(conf, default_port): """ Bind socket to bind ip:port in conf note: Mostly comes from Swift with a few small changes... :param conf: a cfg.ConfigOpts object :param default_port: port to bind to if none is specified in conf :returns : a socket object as returned from socket.listen or ssl.wrap_socket if conf specifies cert_file """ bind_addr = get_bind_addr(conf, default_port) # TODO(jaypipes): eventlet's greened socket module does not actually # support IPv6 in getaddrinfo(). We need to get around this in the # future or monitor upstream for a fix address_family = [addr[0] for addr in socket.getaddrinfo(bind_addr[0], bind_addr[1], socket.AF_UNSPEC, socket.SOCK_STREAM) if addr[0] in (socket.AF_INET, socket.AF_INET6)][0] cert_file = conf.cert_file key_file = conf.key_file use_ssl = cert_file or key_file if use_ssl and (not cert_file or not key_file): raise RuntimeError(_("When running server in SSL mode, you must " "specify both a cert_file and key_file " "option value in your configuration file")) sock = None retry_until = time.time() + 30 while not sock and time.time() < retry_until: try: sock = eventlet.listen(bind_addr, backlog=conf.backlog, family=address_family) if use_ssl: sock = ssl.wrap_socket(sock, certfile=cert_file, keyfile=key_file) except socket.error as err: if err.args[0] != errno.EADDRINUSE: raise eventlet.sleep(0.1) if not sock: raise RuntimeError(_("Could not bind to %(bind_addr)s" "after trying for 30 seconds") % {'bind_addr': bind_addr}) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # in my experience, sockets can hang around forever without keepalive sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # This option isn't available in the OS X version of eventlet if hasattr(socket, 'TCP_KEEPIDLE'): sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 600) return sock class Server(object): """Server class to manage multiple WSGI sockets and applications.""" def __init__(self, threads=1000): self.threads = threads self.children = [] self.running = True def start(self, application, conf, default_port): """ Run a WSGI server with the given application. :param application: The application to run in the WSGI server :param conf: a cfg.ConfigOpts object :param default_port: Port to bind to if none is specified in conf """ def kill_children(*args): """Kills the entire process group.""" self.logger.error(_('SIGTERM received')) signal.signal(signal.SIGTERM, signal.SIG_IGN) self.running = False os.killpg(0, signal.SIGTERM) def hup(*args): """ Shuts down the server, but allows running requests to complete """ self.logger.error(_('SIGHUP received')) signal.signal(signal.SIGHUP, signal.SIG_IGN) self.running = False eventlet.wsgi.MAX_HEADER_LINE = conf.max_header_line self.application = application self.sock = get_socket(conf, default_port) self.logger = logging.getLogger('eventlet.wsgi.server') if conf.workers == 0: # Useful for profiling, test, debug etc. self.pool = eventlet.GreenPool(size=self.threads) self.pool.spawn_n(self._single_run, application, self.sock) return self.logger.info(_("Starting %d workers") % conf.workers) signal.signal(signal.SIGTERM, kill_children) signal.signal(signal.SIGHUP, hup) while len(self.children) < conf.workers: self.run_child() def wait_on_children(self): while self.running: try: pid, status = os.wait() if os.WIFEXITED(status) or os.WIFSIGNALED(status): self.logger.error(_('Removing dead child %s') % pid) self.children.remove(pid) self.run_child() except OSError as err: if err.errno not in (errno.EINTR, errno.ECHILD): raise except KeyboardInterrupt: self.logger.info(_('Caught keyboard interrupt. Exiting.')) break eventlet.greenio.shutdown_safe(self.sock) self.sock.close() self.logger.debug(_('Exited')) def wait(self): """Wait until all servers have completed running.""" try: if self.children: self.wait_on_children() else: self.pool.waitall() except KeyboardInterrupt: pass def run_child(self): pid = os.fork() if pid == 0: signal.signal(signal.SIGHUP, signal.SIG_DFL) signal.signal(signal.SIGTERM, signal.SIG_DFL) self.run_server() self.logger.info(_('Child %d exiting normally') % os.getpid()) return else: self.logger.info(_('Started child %s') % pid) self.children.append(pid) def run_server(self): """Run a WSGI server.""" eventlet.wsgi.HttpProtocol.default_request_version = "HTTP/1.0" eventlet.hubs.use_hub('poll') eventlet.patcher.monkey_patch(all=False, socket=True) self.pool = eventlet.GreenPool(size=self.threads) try: eventlet.wsgi.server(self.sock, self.application, custom_pool=self.pool, url_length_limit=URL_LENGTH_LIMIT, log=WritableLogger(self.logger), debug=cfg.CONF.debug) except socket.error as err: if err[0] != errno.EINVAL: raise self.pool.waitall() def _single_run(self, application, sock): """Start a WSGI server in a new green thread.""" self.logger.info(_("Starting single process server")) eventlet.wsgi.server(sock, application, custom_pool=self.pool, url_length_limit=URL_LENGTH_LIMIT, log=WritableLogger(self.logger)) class Middleware(object): """ Base WSGI middleware wrapper. These classes require an application to be initialized that will be called next. By default the middleware will simply call its wrapped app, or you can override __call__ to customize its behavior. """ def __init__(self, application): self.application = application def process_request(self, req): """ Called on each request. If this returns None, the next application down the stack will be executed. If it returns a response then that response will be returned and execution will stop here. """ return None def process_response(self, response): """Do whatever you'd like to the response.""" return response @webob.dec.wsgify def __call__(self, req): response = self.process_request(req) if response: return response response = req.get_response(self.application) return self.process_response(response) class Debug(Middleware): """ Helper class that can be inserted into any WSGI application chain to get information about the request and response. """ @webob.dec.wsgify def __call__(self, req): print(("*" * 40) + " REQUEST ENVIRON") for key, value in req.environ.items(): print(key, "=", value) print resp = req.get_response(self.application) print(("*" * 40) + " RESPONSE HEADERS") for (key, value) in resp.headers.iteritems(): print(key, "=", value) print resp.app_iter = self.print_generator(resp.app_iter) return resp @staticmethod def print_generator(app_iter): """ Iterator that prints the contents of a wrapper string iterator when iterated. """ print(("*" * 40) + " BODY") for part in app_iter: sys.stdout.write(part) sys.stdout.flush() yield part print def debug_filter(app, conf, **local_conf): return Debug(app) class Router(object): """ WSGI middleware that maps incoming requests to WSGI apps. """ def __init__(self, mapper): """ Create a router for the given routes.Mapper. Each route in `mapper` must specify a 'controller', which is a WSGI app to call. You'll probably want to specify an 'action' as well and have your controller be a wsgi.Controller, who will route the request to the action method. Examples: mapper = routes.Mapper() sc = ServerController() # Explicit mapping of one route to a controller+action mapper.connect(None, "/svrlist", controller=sc, action="list") # Actions are all implicitly defined mapper.resource("server", "servers", controller=sc) # Pointing to an arbitrary WSGI app. You can specify the # {path_info:.*} parameter so the target app can be handed just that # section of the URL. mapper.connect(None, "/v1.0/{path_info:.*}", controller=BlogApp()) """ self.map = mapper self._router = routes.middleware.RoutesMiddleware(self._dispatch, self.map) @webob.dec.wsgify def __call__(self, req): """ Route the incoming request to a controller based on self.map. If no match, return a 404. """ return self._router @staticmethod @webob.dec.wsgify def _dispatch(req): """ Called by self._router after matching the incoming request to a route and putting the information into req.environ. Either returns 404 or the routed WSGI app's response. """ match = req.environ['wsgiorg.routing_args'][1] if not match: return webob.exc.HTTPNotFound() app = match['controller'] return app class Request(webob.Request): """Add some OpenStack API-specific logic to the base webob.Request.""" def best_match_content_type(self): """Determine the requested response content-type.""" supported = ('application/json',) bm = self.accept.best_match(supported) return bm or 'application/json' def get_content_type(self, allowed_content_types): """Determine content type of the request body.""" if "Content-Type" not in self.headers: raise exception.InvalidContentType(content_type=None) content_type = self.content_type if content_type not in allowed_content_types: raise exception.InvalidContentType(content_type=content_type) else: return content_type def best_match_language(self): """Determines best available locale from the Accept-Language header. :returns: the best language match or None if the 'Accept-Language' header was not available in the request. """ if not self.accept_language: return None all_languages = gettextutils.get_available_languages('heat') return self.accept_language.best_match(all_languages) def is_json_content_type(request): if request.method == 'GET': try: aws_content_type = request.params.get("ContentType") except Exception: aws_content_type = None #respect aws_content_type when both available content_type = aws_content_type or request.content_type else: content_type = request.content_type #bug #1887882 #for back compatible for null or plain content type if not content_type or content_type.startswith('text/plain'): content_type = 'application/json' if content_type in ('JSON', 'application/json')\ and request.body.startswith('{'): return True return False class JSONRequestDeserializer(object): def has_body(self, request): """ Returns whether a Webob.Request object will possess an entity body. :param request: Webob.Request object """ if request.content_length > 0 and is_json_content_type(request): return True return False def from_json(self, datastring): try: if len(datastring) > cfg.CONF.max_json_body_size: msg = _('JSON body size (%(len)s bytes) exceeds maximum ' 'allowed size (%(limit)s bytes).') % \ {'len': len(datastring), 'limit': cfg.CONF.max_json_body_size} raise exception.RequestLimitExceeded(message=msg) return json.loads(datastring) except ValueError as ex: raise webob.exc.HTTPBadRequest(str(ex)) def default(self, request): if self.has_body(request): return {'body': self.from_json(request.body)} else: return {} class JSONResponseSerializer(object): def to_json(self, data): def sanitizer(obj): if isinstance(obj, datetime.datetime): return obj.isoformat() return obj response = json.dumps(data, default=sanitizer) logging.debug("JSON response : %s" % response) return response def default(self, response, result): response.content_type = 'application/json' response.body = self.to_json(result) # Escape XML serialization for these keys, as the AWS API defines them as # JSON inside XML when the response format is XML. JSON_ONLY_KEYS = ('TemplateBody', 'Metadata') class XMLResponseSerializer(object): def object_to_element(self, obj, element): if isinstance(obj, list): for item in obj: subelement = etree.SubElement(element, "member") self.object_to_element(item, subelement) elif isinstance(obj, dict): for key, value in obj.items(): subelement = etree.SubElement(element, key) if key in JSON_ONLY_KEYS: if value: # Need to use json.dumps for the JSON inside XML # otherwise quotes get mangled and json.loads breaks try: subelement.text = json.dumps(value) except TypeError: subelement.text = str(value) else: self.object_to_element(value, subelement) else: element.text = str(obj) def to_xml(self, data): # Assumption : root node is dict with single key root = data.keys()[0] eltree = etree.Element(root) self.object_to_element(data.get(root), eltree) response = etree.tostring(eltree) logging.debug("XML response : %s" % response) return response def default(self, response, result): response.content_type = 'application/xml' response.body = self.to_xml(result) class Resource(object): """ WSGI app that handles (de)serialization and controller dispatch. Reads routing information supplied by RoutesMiddleware and calls the requested action method upon its deserializer, controller, and serializer. Those three objects may implement any of the basic controller action methods (create, update, show, index, delete) along with any that may be specified in the api router. A 'default' method may also be implemented to be used in place of any non-implemented actions. Deserializer methods must accept a request argument and return a dictionary. Controller methods must accept a request argument. Additionally, they must also accept keyword arguments that represent the keys returned by the Deserializer. They may raise a webob.exc exception or return a dict, which will be serialized by requested content type. """ def __init__(self, controller, deserializer, serializer=None): """ :param controller: object that implement methods created by routes lib :param deserializer: object that supports webob request deserialization through controller-like actions :param serializer: object that supports webob response serialization through controller-like actions """ self.controller = controller self.deserializer = deserializer self.serializer = serializer @webob.dec.wsgify(RequestClass=Request) def __call__(self, request): """WSGI method that controls (de)serialization and method dispatch.""" action_args = self.get_action_args(request.environ) action = action_args.pop('action', None) # From reading the boto code, and observation of real AWS api responses # it seems that the AWS api ignores the content-type in the html header # Instead it looks at a "ContentType" GET query parameter # This doesn't seem to be documented in the AWS cfn API spec, but it # would appear that the default response serialization is XML, as # described in the API docs, but passing a query parameter of # ContentType=JSON results in a JSON serialized response... content_type = request.params.get("ContentType") try: deserialized_request = self.dispatch(self.deserializer, action, request) action_args.update(deserialized_request) action_result = self.dispatch(self.controller, action, request, **action_args) except TypeError as err: logging.error(_('Exception handling resource: %s') % str(err)) msg = _('The server could not comply with the request since\r\n' 'it is either malformed or otherwise incorrect.\r\n') err = webob.exc.HTTPBadRequest(msg) http_exc = translate_exception(err, request.best_match_language()) # NOTE(luisg): We disguise HTTP exceptions, otherwise they will be # treated by wsgi as responses ready to be sent back and they # won't make it into the pipeline app that serializes errors raise exception.HTTPExceptionDisguise(http_exc) except webob.exc.HTTPException as err: if not isinstance(err, webob.exc.HTTPError): # Some HTTPException are actually not errors, they are # responses ready to be sent back to the users, so we don't # error log, disguise or translate those raise if isinstance(err, webob.exc.HTTPServerError): logging.error( _("Returning %(code)s to user: %(explanation)s"), {'code': err.code, 'explanation': err.explanation}) http_exc = translate_exception(err, request.best_match_language()) raise exception.HTTPExceptionDisguise(http_exc) except exception.HeatException as err: raise translate_exception(err, request.best_match_language()) except Exception as err: log_exception(err, sys.exc_info()) raise translate_exception(err, request.best_match_language()) # Here we support either passing in a serializer or detecting it # based on the content type. try: serializer = self.serializer if serializer is None: if content_type == "JSON": serializer = JSONResponseSerializer() else: serializer = XMLResponseSerializer() response = webob.Response(request=request) self.dispatch(serializer, action, response, action_result) return response # return unserializable result (typically an exception) except Exception: # Here we should get API exceptions derived from HeatAPIException # these implement get_unserialized_body(), which allow us to get # a dict containing the unserialized error response. # We only need to serialize for JSON content_type, as the # exception body is pre-serialized to the default XML in the # HeatAPIException constructor # If we get something else here (e.g a webob.exc exception), # this will fail, and we just return it without serializing, # which will not conform to the expected AWS error response format if content_type == "JSON": try: err_body = action_result.get_unserialized_body() serializer.default(action_result, err_body) except Exception: logging.warning(_("Unable to serialize exception " "response")) return action_result def dispatch(self, obj, action, *args, **kwargs): """Find action-specific method on self and call it.""" try: method = getattr(obj, action) except AttributeError: method = getattr(obj, 'default') return method(*args, **kwargs) def get_action_args(self, request_environment): """Parse dictionary created by routes library.""" try: args = request_environment['wsgiorg.routing_args'][1].copy() except Exception: return {} try: del args['controller'] except KeyError: pass try: del args['format'] except KeyError: pass return args def log_exception(err, exc_info): args = {'exc_info': exc_info} if cfg.CONF.verbose or cfg.CONF.debug else {} logging.error(_("Unexpected error occurred serving API: %s") % err, **args) def translate_exception(exc, locale): """Translates all translatable elements of the given exception.""" exc.message = gettextutils.translate(str(exc), locale) if isinstance(exc, webob.exc.HTTPError): # If the explanation is not a Message, that means that the # explanation is the default, generic and not translatable explanation # from webop.exc. Since the explanation is the error shown when the # exception is converted to a response, let's actually swap it with # message, since message is what gets passed in at construction time # in the API if not isinstance(exc.explanation, gettextutils.Message): exc.explanation = str(exc) exc.detail = '' else: exc.explanation = \ gettextutils.translate(exc.explanation, locale) exc.detail = gettextutils.translate(exc.detail, locale) return exc class BasePasteFactory(object): """A base class for paste app and filter factories. Sub-classes must override the KEY class attribute and provide a __call__ method. """ KEY = None def __init__(self, conf): self.conf = conf def __call__(self, global_conf, **local_conf): raise NotImplementedError def _import_factory(self, local_conf): """Import an app/filter class. Lookup the KEY from the PasteDeploy local conf and import the class named there. This class can then be used as an app or filter factory. Note we support the : format. Note also that if you do e.g. key = value then ConfigParser returns a value with a leading newline, so we strip() the value before using it. """ class_name = local_conf[self.KEY].replace(':', '.').strip() return importutils.import_class(class_name) class AppFactory(BasePasteFactory): """A Generic paste.deploy app factory. This requires heat.app_factory to be set to a callable which returns a WSGI app when invoked. The format of the name is : e.g. [app:apiv1app] paste.app_factory = heat.common.wsgi:app_factory heat.app_factory = heat.api.cfn.v1:API The WSGI app constructor must accept a ConfigOpts object and a local config dict as its two arguments. """ KEY = 'heat.app_factory' def __call__(self, global_conf, **local_conf): """The actual paste.app_factory protocol method.""" factory = self._import_factory(local_conf) return factory(self.conf, **local_conf) class FilterFactory(AppFactory): """A Generic paste.deploy filter factory. This requires heat.filter_factory to be set to a callable which returns a WSGI filter when invoked. The format is : e.g. [filter:cache] paste.filter_factory = heat.common.wsgi:filter_factory heat.filter_factory = heat.api.middleware.cache:CacheFilter The WSGI filter constructor must accept a WSGI app, a ConfigOpts object and a local config dict as its three arguments. """ KEY = 'heat.filter_factory' def __call__(self, global_conf, **local_conf): """The actual paste.filter_factory protocol method.""" factory = self._import_factory(local_conf) def filter(app): return factory(app, self.conf, **local_conf) return filter def setup_paste_factories(conf): """Set up the generic paste app and filter factories. Set things up so that: paste.app_factory = heat.common.wsgi:app_factory and paste.filter_factory = heat.common.wsgi:filter_factory work correctly while loading PasteDeploy configuration. The app factories are constructed at runtime to allow us to pass a ConfigOpts object to the WSGI classes. :param conf: a ConfigOpts object """ global app_factory, filter_factory app_factory = AppFactory(conf) filter_factory = FilterFactory(conf) def teardown_paste_factories(): """Reverse the effect of setup_paste_factories().""" global app_factory, filter_factory del app_factory del filter_factory def paste_deploy_app(paste_config_file, app_name, conf): """Load a WSGI app from a PasteDeploy configuration. Use deploy.loadapp() to load the app from the PasteDeploy configuration, ensuring that the supplied ConfigOpts object is passed to the app and filter constructors. :param paste_config_file: a PasteDeploy config file :param app_name: the name of the app/pipeline to load from the file :param conf: a ConfigOpts object to supply to the app and its filters :returns: the WSGI app """ setup_paste_factories(conf) try: return deploy.loadapp("config:%s" % paste_config_file, name=app_name) finally: teardown_paste_factories() heat-2014.1.5/heat/common/systemd.py0000664000567000056700000000250012540642614020301 0ustar jenkinsjenkins00000000000000# Copyright 2012 Red Hat, Inc. # # 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. """ Helper module for systemd start-up completion notification. Used for "onready" configuration parameter in heat.conf """ import os import socket from heat.openstack.common import log as logging logger = logging.getLogger(__name__) def _sd_notify(msg): sysd = os.getenv('NOTIFY_SOCKET') if sysd: sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) if sysd.startswith('@'): # abstract namespace socket sysd = '\0%s' % sysd[1:] sock.connect(sysd) sock.sendall(msg) sock.close() else: logger.warning(_('Unable to notify systemd of startup completion:' ' NOTIFY_SOCKET not set')) def notify(): _sd_notify('READY=1') heat-2014.1.5/heat/common/__init__.py0000664000567000056700000000000012540642611020336 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/common/plugin_loader.py0000664000567000056700000000646312540642614021451 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. ''' Utilities to dynamically load plugin modules. Modules imported this way remain accessible to static imports, regardless of the order in which they are imported. For modules that are not part of an existing package tree, use create_subpackage() to dynamically create a package for them before loading them. ''' import pkgutil import sys import types from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) def _module_name(*components): '''Assemble a fully-qualified module name from its components.''' return '.'.join(components) def create_subpackage(path, parent_package_name, subpackage_name="plugins"): ''' Dynamically create a package into which to load plugins. This allows us to not include an __init__.py in the plugins directory. We must still create a package for plugins to go in, otherwise we get warning messages during import. This also provides a convenient place to store the path(s) to the plugins directory. ''' package_name = _module_name(parent_package_name, subpackage_name) package = types.ModuleType(package_name) package.__path__ = [path] if isinstance(path, basestring) else list(path) sys.modules[package_name] = package return package def _import_module(importer, module_name, package): ''' Import a module dynamically into the specified package, given its name and PEP302 Importer object (which knows the path to look in). ''' # Duplicate copies of modules are bad, so check if this has already been # imported statically if module_name in sys.modules: return sys.modules[module_name] loader = importer.find_module(module_name) if loader is None: return None module = loader.load_module(module_name) # Make this accessible through the parent package for static imports local_name = module_name.partition(package.__name__ + '.')[2] module_components = local_name.split('.') parent = reduce(getattr, module_components[:-1], package) setattr(parent, module_components[-1], module) return module def load_modules(package, ignore_error=False): '''Dynamically load all modules from a given package.''' path = package.__path__ pkg_prefix = package.__name__ + '.' for importer, module_name, is_package in pkgutil.walk_packages(path, pkg_prefix): try: module = _import_module(importer, module_name, package) except ImportError: logger.error(_('Failed to import module %s') % module_name) if not ignore_error: raise else: if module is not None: yield module heat-2014.1.5/heat/common/auth_password.py0000664000567000056700000000747112540642614021510 0ustar jenkinsjenkins00000000000000 # Copyright 2013 OpenStack Foundation # # 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. from keystoneclient import exceptions as keystone_exceptions from keystoneclient.v2_0 import client as keystone_client from webob.exc import HTTPUnauthorized class KeystonePasswordAuthProtocol(object): """ Alternative authentication middleware that uses username and password to authenticate against Keystone instead of validating existing auth token. The benefit being that you no longer require admin/service token to authenticate users. """ def __init__(self, app, conf): self.app = app self.conf = conf def __call__(self, env, start_response): """Authenticate incoming request.""" username = env.get('HTTP_X_AUTH_USER') password = env.get('HTTP_X_AUTH_KEY') # Determine tenant id from path. tenant = env.get('PATH_INFO').split('/')[1] auth_url = env.get('HTTP_X_AUTH_URL') if not tenant: return self._reject_request(env, start_response, auth_url) try: client = keystone_client.Client( username=username, password=password, tenant_id=tenant, auth_url=auth_url) except (keystone_exceptions.Unauthorized, keystone_exceptions.Forbidden, keystone_exceptions.NotFound, keystone_exceptions.AuthorizationFailure): return self._reject_request(env, start_response, auth_url) env['keystone.token_info'] = client.auth_ref env.update(self._build_user_headers(client.auth_ref)) return self.app(env, start_response) def _reject_request(self, env, start_response, auth_url): """Redirect client to auth server.""" headers = [('WWW-Authenticate', 'Keystone uri=\'%s\'' % auth_url)] resp = HTTPUnauthorized('Authentication required', headers) return resp(env, start_response) def _build_user_headers(self, token_info): """Build headers that represent authenticated user from auth token.""" tenant_id = token_info['token']['tenant']['id'] tenant_name = token_info['token']['tenant']['name'] user_id = token_info['user']['id'] user_name = token_info['user']['name'] roles = ','.join( [role['name'] for role in token_info['user']['roles']]) service_catalog = token_info['serviceCatalog'] auth_token = token_info['token']['id'] headers = { 'HTTP_X_IDENTITY_STATUS': 'Confirmed', 'HTTP_X_PROJECT_ID': tenant_id, 'HTTP_X_PROJECT_NAME': tenant_name, 'HTTP_X_USER_ID': user_id, 'HTTP_X_USER_NAME': user_name, 'HTTP_X_ROLES': roles, 'HTTP_X_SERVICE_CATALOG': service_catalog, 'HTTP_X_AUTH_TOKEN': auth_token, # DEPRECATED 'HTTP_X_USER': user_name, 'HTTP_X_TENANT_ID': tenant_id, 'HTTP_X_TENANT_NAME': tenant_name, 'HTTP_X_TENANT': tenant_name, 'HTTP_X_ROLE': roles, } return headers def filter_factory(global_conf, **local_conf): """Returns a WSGI filter app for use with paste.deploy.""" conf = global_conf.copy() conf.update(local_conf) def auth_filter(app): return KeystonePasswordAuthProtocol(app, conf) return auth_filter heat-2014.1.5/heat/common/notify.py0000664000567000056700000000241012540642614020121 0ustar jenkinsjenkins00000000000000# Copyright 2014 Red Hat, Inc. # # 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. """ Startup notification using a shell script or systemd NOTIFY_SOCKET style notification """ from heat.openstack.common import importutils from heat.openstack.common import log as logging from heat.openstack.common import processutils logger = logging.getLogger(__name__) def startup_notify(notify_param): if not notify_param or notify_param == "": return try: notifier = importutils.import_module(notify_param) except ImportError: try: processutils.execute(notify_param, shell=True) except Exception as e: logger.error(_('Failed to execute onready command: %s') % str(e)) else: notifier.notify() heat-2014.1.5/heat/common/template_format.py0000664000567000056700000000751412540642614022006 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. import itertools import json import re from oslo.config import cfg import yaml from heat.common import exception from heat.openstack.common.gettextutils import _ cfg.CONF.import_opt('max_template_size', 'heat.common.config') if hasattr(yaml, 'CSafeLoader'): yaml_loader = yaml.CSafeLoader else: yaml_loader = yaml.SafeLoader if hasattr(yaml, 'CSafeDumper'): yaml_dumper = yaml.CSafeDumper else: yaml_dumper = yaml.SafeDumper def _construct_yaml_str(self, node): # Override the default string handling function # to always return unicode objects return self.construct_scalar(node) yaml_loader.add_constructor(u'tag:yaml.org,2002:str', _construct_yaml_str) # Unquoted dates like 2013-05-23 in yaml files get loaded as objects of type # datetime.data which causes problems in API layer when being processed by # openstack.common.jsonutils. Therefore, make unicode string out of timestamps # until jsonutils can handle dates. yaml_loader.add_constructor(u'tag:yaml.org,2002:timestamp', _construct_yaml_str) def simple_parse(tmpl_str): try: tpl = json.loads(tmpl_str) except ValueError: try: tpl = yaml.load(tmpl_str, Loader=yaml_loader) except yaml.YAMLError as yea: raise ValueError(yea) else: if tpl is None: tpl = {} return tpl def parse(tmpl_str): ''' Takes a string and returns a dict containing the parsed structure. This includes determination of whether the string is using the JSON or YAML format. ''' if len(tmpl_str) > cfg.CONF.max_template_size: msg = (_('Template exceeds maximum allowed size (%s bytes)') % cfg.CONF.max_template_size) raise exception.RequestLimitExceeded(message=msg) tpl = simple_parse(tmpl_str) if not isinstance(tpl, dict): raise ValueError(_('The template is not a JSON object ' 'or YAML mapping.')) # Looking for supported version keys in the loaded template if not ('HeatTemplateFormatVersion' in tpl or 'heat_template_version' in tpl or 'AWSTemplateFormatVersion' in tpl): raise ValueError(_("Template format version not found.")) return tpl def convert_json_to_yaml(json_str): '''Convert a string containing the AWS JSON template format to an equivalent string containing the Heat YAML format. ''' # Replace AWS format version with Heat format version json_str = re.sub('"AWSTemplateFormatVersion"\s*:\s*"[^"]+"\s*,', '', json_str) # insert a sortable order into the key to preserve file ordering key_order = itertools.count() def order_key(matchobj): key = '%s"__%05d__order__%s" :' % ( matchobj.group(1), next(key_order), matchobj.group(2)) return key key_re = re.compile('^(\s*)"([^"]+)"\s*:', re.M) json_str = key_re.sub(order_key, json_str) # parse the string as json to a python structure tpl = yaml.load(json_str, Loader=yaml_loader) # dump python structure to yaml tpl["HeatTemplateFormatVersion"] = '2012-12-12' yml = yaml.dump(tpl, Dumper=yaml_dumper) # remove ordering from key names yml = re.sub('__\d*__order__', '', yml) return yml heat-2014.1.5/heat/common/environment_format.py0000664000567000056700000000306512540642614022534 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. from heat.common.template_format import yaml from heat.common.template_format import yaml_loader SECTIONS = (PARAMETERS, RESOURCE_REGISTRY) = \ ('parameters', 'resource_registry') def parse(env_str): ''' Takes a string and returns a dict containing the parsed structure. ''' if env_str is None: return {} try: env = yaml.load(env_str, Loader=yaml_loader) except yaml.YAMLError as yea: raise ValueError(yea) else: if env is None: env = {} if not isinstance(env, dict): raise ValueError(_('The environment is not a valid ' 'YAML mapping data type.')) for param in env: if param not in SECTIONS: raise ValueError(_('environment has wrong section "%s"') % param) return env def default_for_missing(env): ''' Checks a parsed environment for missing sections. ''' for param in SECTIONS: if param not in env: env[param] = {} heat-2014.1.5/heat/cmd/0000775000567000056700000000000012540643116015513 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/cmd/__init__.py0000664000567000056700000000000012540642611017611 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/cmd/manage.py0000664000567000056700000000525312540642614017324 0ustar jenkinsjenkins00000000000000 # 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. """ CLI interface for heat management. """ import sys from oslo.config import cfg from heat.db import api from heat.db import utils from heat.openstack.common import log from heat import version CONF = cfg.CONF def do_db_version(): """Print database's current migration level.""" print(api.db_version()) def do_db_sync(): """ Place a database under migration control and upgrade, creating first if necessary. """ api.db_sync(CONF.command.version) def purge_deleted(): """ Remove database records that have been previously soft deleted """ utils.purge_deleted(CONF.command.age, CONF.command.granularity) def add_command_parsers(subparsers): parser = subparsers.add_parser('db_version') parser.set_defaults(func=do_db_version) parser = subparsers.add_parser('db_sync') parser.set_defaults(func=do_db_sync) parser.add_argument('version', nargs='?') parser.add_argument('current_version', nargs='?') parser = subparsers.add_parser('purge_deleted') parser.set_defaults(func=purge_deleted) parser.add_argument('age', nargs='?', default='90', help=_('How long to preserve deleted data.')) parser.add_argument( '-g', '--granularity', default='days', choices=['days', 'hours', 'minutes', 'seconds'], help=_('Granularity to use for age argument, defaults to days.')) command_opt = cfg.SubCommandOpt('command', title='Commands', help='Show available commands.', handler=add_command_parsers) def main(): CONF.register_cli_opt(command_opt) try: default_config_files = cfg.find_config_files('heat', 'heat-engine') CONF(sys.argv[1:], project='heat', prog='heat-manage', version=version.version_info.version_string(), default_config_files=default_config_files) log.setup("heat") except RuntimeError as e: sys.exit("ERROR: %s" % e) try: CONF.command.func() except Exception as e: sys.exit("ERROR: %s" % e) heat-2014.1.5/heat/openstack/0000775000567000056700000000000012540643116016737 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/0000775000567000056700000000000012540643116020227 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/lockutils.py0000664000567000056700000002122612540642614022617 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. import contextlib import errno import functools import os import shutil import subprocess import sys import tempfile import threading import time import weakref from oslo.config import cfg from heat.openstack.common import fileutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging LOG = logging.getLogger(__name__) util_opts = [ cfg.BoolOpt('disable_process_locking', default=False, help='Whether to disable inter-process locks'), cfg.StrOpt('lock_path', default=os.environ.get("HEAT_LOCK_PATH"), help=('Directory to use for lock files.')) ] CONF = cfg.CONF CONF.register_opts(util_opts) def set_defaults(lock_path): cfg.set_defaults(util_opts, lock_path=lock_path) class _InterProcessLock(object): """Lock implementation which allows multiple locks, working around issues like bugs.debian.org/cgi-bin/bugreport.cgi?bug=632857 and does not require any cleanup. Since the lock is always held on a file descriptor rather than outside of the process, the lock gets dropped automatically if the process crashes, even if __exit__ is not executed. There are no guarantees regarding usage by multiple green threads in a single process here. This lock works only between processes. Exclusive access between local threads should be achieved using the semaphores in the @synchronized decorator. Note these locks are released when the descriptor is closed, so it's not safe to close the file descriptor while another green thread holds the lock. Just opening and closing the lock file can break synchronisation, so lock files must be accessed only using this abstraction. """ def __init__(self, name): self.lockfile = None self.fname = name def __enter__(self): basedir = os.path.dirname(self.fname) if not os.path.exists(basedir): fileutils.ensure_tree(basedir) LOG.info(_('Created lock path: %s'), basedir) self.lockfile = open(self.fname, 'w') while True: try: # Using non-blocking locks since green threads are not # patched to deal with blocking locking calls. # Also upon reading the MSDN docs for locking(), it seems # to have a laughable 10 attempts "blocking" mechanism. self.trylock() LOG.debug(_('Got file lock "%s"'), self.fname) return self except IOError as e: if e.errno in (errno.EACCES, errno.EAGAIN): # external locks synchronise things like iptables # updates - give it some time to prevent busy spinning time.sleep(0.01) else: raise def __exit__(self, exc_type, exc_val, exc_tb): try: self.unlock() self.lockfile.close() except IOError: LOG.exception(_("Could not release the acquired lock `%s`"), self.fname) LOG.debug(_('Released file lock "%s"'), self.fname) def trylock(self): raise NotImplementedError() def unlock(self): raise NotImplementedError() class _WindowsLock(_InterProcessLock): def trylock(self): msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_NBLCK, 1) def unlock(self): msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_UNLCK, 1) class _PosixLock(_InterProcessLock): def trylock(self): fcntl.lockf(self.lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB) def unlock(self): fcntl.lockf(self.lockfile, fcntl.LOCK_UN) if os.name == 'nt': import msvcrt InterProcessLock = _WindowsLock else: import fcntl InterProcessLock = _PosixLock _semaphores = weakref.WeakValueDictionary() _semaphores_lock = threading.Lock() def external_lock(name, lock_file_prefix=None): with internal_lock(name): LOG.debug(_('Attempting to grab external lock "%(lock)s"'), {'lock': name}) # NOTE(mikal): the lock name cannot contain directory # separators name = name.replace(os.sep, '_') if lock_file_prefix: sep = '' if lock_file_prefix.endswith('-') else '-' name = '%s%s%s' % (lock_file_prefix, sep, name) if not CONF.lock_path: raise cfg.RequiredOptError('lock_path') lock_file_path = os.path.join(CONF.lock_path, name) return InterProcessLock(lock_file_path) def internal_lock(name): with _semaphores_lock: try: sem = _semaphores[name] except KeyError: sem = threading.Semaphore() _semaphores[name] = sem LOG.debug(_('Got semaphore "%(lock)s"'), {'lock': name}) return sem @contextlib.contextmanager def lock(name, lock_file_prefix=None, external=False): """Context based lock This function yields a `threading.Semaphore` instance (if we don't use eventlet.monkey_patch(), else `semaphore.Semaphore`) unless external is True, in which case, it'll yield an InterProcessLock instance. :param lock_file_prefix: The lock_file_prefix argument is used to provide lock files on disk with a meaningful prefix. :param external: The external keyword argument denotes whether this lock should work across multiple processes. This means that if two different workers both run a a method decorated with @synchronized('mylock', external=True), only one of them will execute at a time. """ if external and not CONF.disable_process_locking: lock = external_lock(name, lock_file_prefix) else: lock = internal_lock(name) with lock: yield lock def synchronized(name, lock_file_prefix=None, external=False): """Synchronization decorator. Decorating a method like so:: @synchronized('mylock') def foo(self, *args): ... ensures that only one thread will execute the foo method at a time. Different methods can share the same lock:: @synchronized('mylock') def foo(self, *args): ... @synchronized('mylock') def bar(self, *args): ... This way only one of either foo or bar can be executing at a time. """ def wrap(f): @functools.wraps(f) def inner(*args, **kwargs): try: with lock(name, lock_file_prefix, external): LOG.debug(_('Got semaphore / lock "%(function)s"'), {'function': f.__name__}) return f(*args, **kwargs) finally: LOG.debug(_('Semaphore / lock released "%(function)s"'), {'function': f.__name__}) return inner return wrap def synchronized_with_prefix(lock_file_prefix): """Partial object generator for the synchronization decorator. Redefine @synchronized in each project like so:: (in nova/utils.py) from nova.openstack.common import lockutils synchronized = lockutils.synchronized_with_prefix('nova-') (in nova/foo.py) from nova import utils @utils.synchronized('mylock') def bar(self, *args): ... The lock_file_prefix argument is used to provide lock files on disk with a meaningful prefix. """ return functools.partial(synchronized, lock_file_prefix=lock_file_prefix) def main(argv): """Create a dir for locks and pass it to command from arguments If you run this: python -m openstack.common.lockutils python setup.py testr a temporary directory will be created for all your locks and passed to all your tests in an environment variable. The temporary dir will be deleted afterwards and the return value will be preserved. """ lock_dir = tempfile.mkdtemp() os.environ["HEAT_LOCK_PATH"] = lock_dir try: ret_val = subprocess.call(argv[1:]) finally: shutil.rmtree(lock_dir, ignore_errors=True) return ret_val if __name__ == '__main__': sys.exit(main(sys.argv)) heat-2014.1.5/heat/openstack/common/db/0000775000567000056700000000000012540643116020614 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/db/exception.py0000664000567000056700000000347512540642614023177 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # 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. """DB related custom exceptions.""" from heat.openstack.common.gettextutils import _ class DBError(Exception): """Wraps an implementation specific exception.""" def __init__(self, inner_exception=None): self.inner_exception = inner_exception super(DBError, self).__init__(str(inner_exception)) class DBDuplicateEntry(DBError): """Wraps an implementation specific exception.""" def __init__(self, columns=[], inner_exception=None): self.columns = columns super(DBDuplicateEntry, self).__init__(inner_exception) class DBDeadlock(DBError): def __init__(self, inner_exception=None): super(DBDeadlock, self).__init__(inner_exception) class DBInvalidUnicodeParameter(Exception): message = _("Invalid Parameter: " "Unicode is not supported by the current database.") class DbMigrationError(DBError): """Wraps migration specific exception.""" def __init__(self, message=None): super(DbMigrationError, self).__init__(str(message)) class DBConnectionError(DBError): """Wraps connection specific exception.""" pass heat-2014.1.5/heat/openstack/common/db/sqlalchemy/0000775000567000056700000000000012540643116022756 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/db/sqlalchemy/provision.py0000664000567000056700000001311312540642614025361 0ustar jenkinsjenkins00000000000000# Copyright 2013 Mirantis.inc # 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. """Provision test environment for specific DB backends""" import argparse import os import random import string from six import moves import sqlalchemy from heat.openstack.common.db import exception as exc SQL_CONNECTION = os.getenv('OS_TEST_DBAPI_ADMIN_CONNECTION', 'sqlite://') def _gen_credentials(*names): """Generate credentials.""" auth_dict = {} for name in names: val = ''.join(random.choice(string.ascii_lowercase) for i in moves.range(10)) auth_dict[name] = val return auth_dict def _get_engine(uri=SQL_CONNECTION): """Engine creation By default the uri is SQL_CONNECTION which is admin credentials. Call the function without arguments to get admin connection. Admin connection required to create temporary user and database for each particular test. Otherwise use existing connection to recreate connection to the temporary database. """ return sqlalchemy.create_engine(uri, poolclass=sqlalchemy.pool.NullPool) def _execute_sql(engine, sql, driver): """Initialize connection, execute sql query and close it.""" try: with engine.connect() as conn: if driver == 'postgresql': conn.connection.set_isolation_level(0) for s in sql: conn.execute(s) except sqlalchemy.exc.OperationalError: msg = ('%s does not match database admin ' 'credentials or database does not exist.') raise exc.DBConnectionError(msg % SQL_CONNECTION) def create_database(engine): """Provide temporary user and database for each particular test.""" driver = engine.name auth = _gen_credentials('database', 'user', 'passwd') sqls = { 'mysql': [ "drop database if exists %(database)s;", "grant all on %(database)s.* to '%(user)s'@'localhost'" " identified by '%(passwd)s';", "create database %(database)s;", ], 'postgresql': [ "drop database if exists %(database)s;", "drop user if exists %(user)s;", "create user %(user)s with password '%(passwd)s';", "create database %(database)s owner %(user)s;", ] } if driver == 'sqlite': return 'sqlite:////tmp/%s' % auth['database'] try: sql_rows = sqls[driver] except KeyError: raise ValueError('Unsupported RDBMS %s' % driver) sql_query = map(lambda x: x % auth, sql_rows) _execute_sql(engine, sql_query, driver) params = auth.copy() params['backend'] = driver return "%(backend)s://%(user)s:%(passwd)s@localhost/%(database)s" % params def drop_database(engine, current_uri): """Drop temporary database and user after each particular test.""" engine = _get_engine(current_uri) admin_engine = _get_engine() driver = engine.name auth = {'database': engine.url.database, 'user': engine.url.username} if driver == 'sqlite': try: os.remove(auth['database']) except OSError: pass return sqls = { 'mysql': [ "drop database if exists %(database)s;", "drop user '%(user)s'@'localhost';", ], 'postgresql': [ "drop database if exists %(database)s;", "drop user if exists %(user)s;", ] } try: sql_rows = sqls[driver] except KeyError: raise ValueError('Unsupported RDBMS %s' % driver) sql_query = map(lambda x: x % auth, sql_rows) _execute_sql(admin_engine, sql_query, driver) def main(): """Controller to handle commands ::create: Create test user and database with random names. ::drop: Drop user and database created by previous command. """ parser = argparse.ArgumentParser( description='Controller to handle database creation and dropping' ' commands.', epilog='Under normal circumstances is not used directly.' ' Used in .testr.conf to automate test database creation' ' and dropping processes.') subparsers = parser.add_subparsers( help='Subcommands to manipulate temporary test databases.') create = subparsers.add_parser( 'create', help='Create temporary test ' 'databases and users.') create.set_defaults(which='create') create.add_argument( 'instances_count', type=int, help='Number of databases to create.') drop = subparsers.add_parser( 'drop', help='Drop temporary test databases and users.') drop.set_defaults(which='drop') drop.add_argument( 'instances', nargs='+', help='List of databases uri to be dropped.') args = parser.parse_args() engine = _get_engine() which = args.which if which == "create": for i in range(int(args.instances_count)): print(create_database(engine)) elif which == "drop": for db in args.instances: drop_database(engine, db) if __name__ == "__main__": main() heat-2014.1.5/heat/openstack/common/db/sqlalchemy/models.py0000664000567000056700000000757712540642614024635 0ustar jenkinsjenkins00000000000000# Copyright (c) 2011 X.commerce, a business unit of eBay Inc. # Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2011 Piston Cloud Computing, Inc. # Copyright 2012 Cloudscaling Group, Inc. # 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. """ SQLAlchemy models. """ import six from sqlalchemy import Column, Integer from sqlalchemy import DateTime from sqlalchemy.orm import object_mapper from heat.openstack.common.db.sqlalchemy import session as sa from heat.openstack.common import timeutils class ModelBase(object): """Base class for models.""" __table_initialized__ = False def save(self, session=None): """Save this object.""" if not session: session = sa.get_session() # NOTE(boris-42): This part of code should be look like: # session.add(self) # session.flush() # But there is a bug in sqlalchemy and eventlet that # raises NoneType exception if there is no running # transaction and rollback is called. As long as # sqlalchemy has this bug we have to create transaction # explicitly. with session.begin(subtransactions=True): session.add(self) session.flush() def __setitem__(self, key, value): setattr(self, key, value) def __getitem__(self, key): return getattr(self, key) def get(self, key, default=None): return getattr(self, key, default) @property def _extra_keys(self): """Specifies custom fields Subclasses can override this property to return a list of custom fields that should be included in their dict representation. For reference check tests/db/sqlalchemy/test_models.py """ return [] def __iter__(self): columns = dict(object_mapper(self).columns).keys() # NOTE(russellb): Allow models to specify other keys that can be looked # up, beyond the actual db columns. An example would be the 'name' # property for an Instance. columns.extend(self._extra_keys) self._i = iter(columns) return self def next(self): n = six.advance_iterator(self._i) return n, getattr(self, n) def update(self, values): """Make the model object behave like a dict.""" for k, v in six.iteritems(values): setattr(self, k, v) def iteritems(self): """Make the model object behave like a dict. Includes attributes from joins. """ local = dict(self) joined = dict([(k, v) for k, v in six.iteritems(self.__dict__) if not k[0] == '_']) local.update(joined) return six.iteritems(local) class TimestampMixin(object): created_at = Column(DateTime, default=lambda: timeutils.utcnow()) updated_at = Column(DateTime, onupdate=lambda: timeutils.utcnow()) class SoftDeleteMixin(object): deleted_at = Column(DateTime) deleted = Column(Integer, default=0) def soft_delete(self, session=None): """Mark this object as deleted.""" self.deleted = self.id self.deleted_at = timeutils.utcnow() self.save(session=session) heat-2014.1.5/heat/openstack/common/db/sqlalchemy/session.py0000664000567000056700000010165512540642614025025 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # 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. """Session Handling for SQLAlchemy backend. Initializing: * Call set_defaults with the minimal of the following kwargs: sql_connection, sqlite_db Example:: session.set_defaults( sql_connection="sqlite:///var/lib/heat/sqlite.db", sqlite_db="/var/lib/heat/sqlite.db") Recommended ways to use sessions within this framework: * Don't use them explicitly; this is like running with AUTOCOMMIT=1. model_query() will implicitly use a session when called without one supplied. This is the ideal situation because it will allow queries to be automatically retried if the database connection is interrupted. Note: Automatic retry will be enabled in a future patch. It is generally fine to issue several queries in a row like this. Even though they may be run in separate transactions and/or separate sessions, each one will see the data from the prior calls. If needed, undo- or rollback-like functionality should be handled at a logical level. For an example, look at the code around quotas and reservation_rollback(). Examples:: def get_foo(context, foo): return (model_query(context, models.Foo). filter_by(foo=foo). first()) def update_foo(context, id, newfoo): (model_query(context, models.Foo). filter_by(id=id). update({'foo': newfoo})) def create_foo(context, values): foo_ref = models.Foo() foo_ref.update(values) foo_ref.save() return foo_ref * Within the scope of a single method, keeping all the reads and writes within the context managed by a single session. In this way, the session's __exit__ handler will take care of calling flush() and commit() for you. If using this approach, you should not explicitly call flush() or commit(). Any error within the context of the session will cause the session to emit a ROLLBACK. Database Errors like IntegrityError will be raised in session's __exit__ handler, and any try/except within the context managed by session will not be triggered. And catching other non-database errors in the session will not trigger the ROLLBACK, so exception handlers should always be outside the session, unless the developer wants to do a partial commit on purpose. If the connection is dropped before this is possible, the database will implicitly roll back the transaction. Note: statements in the session scope will not be automatically retried. If you create models within the session, they need to be added, but you do not need to call model.save() :: def create_many_foo(context, foos): session = get_session() with session.begin(): for foo in foos: foo_ref = models.Foo() foo_ref.update(foo) session.add(foo_ref) def update_bar(context, foo_id, newbar): session = get_session() with session.begin(): foo_ref = (model_query(context, models.Foo, session). filter_by(id=foo_id). first()) (model_query(context, models.Bar, session). filter_by(id=foo_ref['bar_id']). update({'bar': newbar})) Note: update_bar is a trivially simple example of using "with session.begin". Whereas create_many_foo is a good example of when a transaction is needed, it is always best to use as few queries as possible. The two queries in update_bar can be better expressed using a single query which avoids the need for an explicit transaction. It can be expressed like so:: def update_bar(context, foo_id, newbar): subq = (model_query(context, models.Foo.id). filter_by(id=foo_id). limit(1). subquery()) (model_query(context, models.Bar). filter_by(id=subq.as_scalar()). update({'bar': newbar})) For reference, this emits approximately the following SQL statement:: UPDATE bar SET bar = ${newbar} WHERE id=(SELECT bar_id FROM foo WHERE id = ${foo_id} LIMIT 1); Note: create_duplicate_foo is a trivially simple example of catching an exception while using "with session.begin". Here create two duplicate instances with same primary key, must catch the exception out of context managed by a single session: def create_duplicate_foo(context): foo1 = models.Foo() foo2 = models.Foo() foo1.id = foo2.id = 1 session = get_session() try: with session.begin(): session.add(foo1) session.add(foo2) except exception.DBDuplicateEntry as e: handle_error(e) * Passing an active session between methods. Sessions should only be passed to private methods. The private method must use a subtransaction; otherwise SQLAlchemy will throw an error when you call session.begin() on an existing transaction. Public methods should not accept a session parameter and should not be involved in sessions within the caller's scope. Note that this incurs more overhead in SQLAlchemy than the above means due to nesting transactions, and it is not possible to implicitly retry failed database operations when using this approach. This also makes code somewhat more difficult to read and debug, because a single database transaction spans more than one method. Error handling becomes less clear in this situation. When this is needed for code clarity, it should be clearly documented. :: def myfunc(foo): session = get_session() with session.begin(): # do some database things bar = _private_func(foo, session) return bar def _private_func(foo, session=None): if not session: session = get_session() with session.begin(subtransaction=True): # do some other database things return bar There are some things which it is best to avoid: * Don't keep a transaction open any longer than necessary. This means that your "with session.begin()" block should be as short as possible, while still containing all the related calls for that transaction. * Avoid "with_lockmode('UPDATE')" when possible. In MySQL/InnoDB, when a "SELECT ... FOR UPDATE" query does not match any rows, it will take a gap-lock. This is a form of write-lock on the "gap" where no rows exist, and prevents any other writes to that space. This can effectively prevent any INSERT into a table by locking the gap at the end of the index. Similar problems will occur if the SELECT FOR UPDATE has an overly broad WHERE clause, or doesn't properly use an index. One idea proposed at ODS Fall '12 was to use a normal SELECT to test the number of rows matching a query, and if only one row is returned, then issue the SELECT FOR UPDATE. The better long-term solution is to use INSERT .. ON DUPLICATE KEY UPDATE. However, this can not be done until the "deleted" columns are removed and proper UNIQUE constraints are added to the tables. Enabling soft deletes: * To use/enable soft-deletes, the SoftDeleteMixin must be added to your model class. For example:: class NovaBase(models.SoftDeleteMixin, models.ModelBase): pass Efficient use of soft deletes: * There are two possible ways to mark a record as deleted:: model.soft_delete() and query.soft_delete(). model.soft_delete() method works with single already fetched entry. query.soft_delete() makes only one db request for all entries that correspond to query. * In almost all cases you should use query.soft_delete(). Some examples:: def soft_delete_bar(): count = model_query(BarModel).find(some_condition).soft_delete() if count == 0: raise Exception("0 entries were soft deleted") def complex_soft_delete_with_synchronization_bar(session=None): if session is None: session = get_session() with session.begin(subtransactions=True): count = (model_query(BarModel). find(some_condition). soft_delete(synchronize_session=True)) # Here synchronize_session is required, because we # don't know what is going on in outer session. if count == 0: raise Exception("0 entries were soft deleted") * There is only one situation where model.soft_delete() is appropriate: when you fetch a single record, work with it, and mark it as deleted in the same transaction. :: def soft_delete_bar_model(): session = get_session() with session.begin(): bar_ref = model_query(BarModel).find(some_condition).first() # Work with bar_ref bar_ref.soft_delete(session=session) However, if you need to work with all entries that correspond to query and then soft delete them you should use query.soft_delete() method:: def soft_delete_multi_models(): session = get_session() with session.begin(): query = (model_query(BarModel, session=session). find(some_condition)) model_refs = query.all() # Work with model_refs query.soft_delete(synchronize_session=False) # synchronize_session=False should be set if there is no outer # session and these entries are not used after this. When working with many rows, it is very important to use query.soft_delete, which issues a single query. Using model.soft_delete(), as in the following example, is very inefficient. :: for bar_ref in bar_refs: bar_ref.soft_delete(session=session) # This will produce count(bar_refs) db requests. """ import functools import os.path import re import time from oslo.config import cfg import six from sqlalchemy import exc as sqla_exc from sqlalchemy.interfaces import PoolListener import sqlalchemy.orm from sqlalchemy.pool import NullPool, StaticPool from sqlalchemy.sql.expression import literal_column from heat.openstack.common.db import exception from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import timeutils sqlite_db_opts = [ cfg.StrOpt('sqlite_db', default='heat.sqlite', help='the filename to use with sqlite'), cfg.BoolOpt('sqlite_synchronous', default=True, help='If true, use synchronous mode for sqlite'), ] database_opts = [ cfg.StrOpt('connection', default='sqlite:///' + os.path.abspath(os.path.join(os.path.dirname(__file__), '../', '$sqlite_db')), help='The SQLAlchemy connection string used to connect to the ' 'database', secret=True, deprecated_opts=[cfg.DeprecatedOpt('sql_connection', group='DEFAULT'), cfg.DeprecatedOpt('sql_connection', group='DATABASE'), cfg.DeprecatedOpt('connection', group='sql'), ]), cfg.StrOpt('slave_connection', default='', secret=True, help='The SQLAlchemy connection string used to connect to the ' 'slave database'), cfg.IntOpt('idle_timeout', default=3600, deprecated_opts=[cfg.DeprecatedOpt('sql_idle_timeout', group='DEFAULT'), cfg.DeprecatedOpt('sql_idle_timeout', group='DATABASE'), cfg.DeprecatedOpt('idle_timeout', group='sql')], help='timeout before idle sql connections are reaped'), cfg.IntOpt('min_pool_size', default=1, deprecated_opts=[cfg.DeprecatedOpt('sql_min_pool_size', group='DEFAULT'), cfg.DeprecatedOpt('sql_min_pool_size', group='DATABASE')], help='Minimum number of SQL connections to keep open in a ' 'pool'), cfg.IntOpt('max_pool_size', default=None, deprecated_opts=[cfg.DeprecatedOpt('sql_max_pool_size', group='DEFAULT'), cfg.DeprecatedOpt('sql_max_pool_size', group='DATABASE')], help='Maximum number of SQL connections to keep open in a ' 'pool'), cfg.IntOpt('max_retries', default=10, deprecated_opts=[cfg.DeprecatedOpt('sql_max_retries', group='DEFAULT'), cfg.DeprecatedOpt('sql_max_retries', group='DATABASE')], help='maximum db connection retries during startup. ' '(setting -1 implies an infinite retry count)'), cfg.IntOpt('retry_interval', default=10, deprecated_opts=[cfg.DeprecatedOpt('sql_retry_interval', group='DEFAULT'), cfg.DeprecatedOpt('reconnect_interval', group='DATABASE')], help='interval between retries of opening a sql connection'), cfg.IntOpt('max_overflow', default=None, deprecated_opts=[cfg.DeprecatedOpt('sql_max_overflow', group='DEFAULT'), cfg.DeprecatedOpt('sqlalchemy_max_overflow', group='DATABASE')], help='If set, use this value for max_overflow with sqlalchemy'), cfg.IntOpt('connection_debug', default=0, deprecated_opts=[cfg.DeprecatedOpt('sql_connection_debug', group='DEFAULT')], help='Verbosity of SQL debugging information. 0=None, ' '100=Everything'), cfg.BoolOpt('connection_trace', default=False, deprecated_opts=[cfg.DeprecatedOpt('sql_connection_trace', group='DEFAULT')], help='Add python stack traces to SQL as comment strings'), cfg.IntOpt('pool_timeout', default=None, deprecated_opts=[cfg.DeprecatedOpt('sqlalchemy_pool_timeout', group='DATABASE')], help='If set, use this value for pool_timeout with sqlalchemy'), ] CONF = cfg.CONF CONF.register_opts(sqlite_db_opts) CONF.register_opts(database_opts, 'database') LOG = logging.getLogger(__name__) _ENGINE = None _MAKER = None _SLAVE_ENGINE = None _SLAVE_MAKER = None def set_defaults(sql_connection, sqlite_db, max_pool_size=None, max_overflow=None, pool_timeout=None): """Set defaults for configuration variables.""" cfg.set_defaults(database_opts, connection=sql_connection) cfg.set_defaults(sqlite_db_opts, sqlite_db=sqlite_db) # Update the QueuePool defaults if max_pool_size is not None: cfg.set_defaults(database_opts, max_pool_size=max_pool_size) if max_overflow is not None: cfg.set_defaults(database_opts, max_overflow=max_overflow) if pool_timeout is not None: cfg.set_defaults(database_opts, pool_timeout=pool_timeout) def cleanup(): global _ENGINE, _MAKER global _SLAVE_ENGINE, _SLAVE_MAKER if _MAKER: _MAKER.close_all() _MAKER = None if _ENGINE: _ENGINE.dispose() _ENGINE = None if _SLAVE_MAKER: _SLAVE_MAKER.close_all() _SLAVE_MAKER = None if _SLAVE_ENGINE: _SLAVE_ENGINE.dispose() _SLAVE_ENGINE = None class SqliteForeignKeysListener(PoolListener): """Ensures that the foreign key constraints are enforced in SQLite. The foreign key constraints are disabled by default in SQLite, so the foreign key constraints will be enabled here for every database connection """ def connect(self, dbapi_con, con_record): dbapi_con.execute('pragma foreign_keys=ON') def get_session(autocommit=True, expire_on_commit=False, sqlite_fk=False, slave_session=False, mysql_traditional_mode=False): """Return a SQLAlchemy session.""" global _MAKER global _SLAVE_MAKER maker = _MAKER if slave_session: maker = _SLAVE_MAKER if maker is None: engine = get_engine(sqlite_fk=sqlite_fk, slave_engine=slave_session, mysql_traditional_mode=mysql_traditional_mode) maker = get_maker(engine, autocommit, expire_on_commit) if slave_session: _SLAVE_MAKER = maker else: _MAKER = maker session = maker() return session # note(boris-42): In current versions of DB backends unique constraint # violation messages follow the structure: # # sqlite: # 1 column - (IntegrityError) column c1 is not unique # N columns - (IntegrityError) column c1, c2, ..., N are not unique # # sqlite since 3.7.16: # 1 column - (IntegrityError) UNIQUE constraint failed: k1 # # N columns - (IntegrityError) UNIQUE constraint failed: k1, k2 # # postgres: # 1 column - (IntegrityError) duplicate key value violates unique # constraint "users_c1_key" # N columns - (IntegrityError) duplicate key value violates unique # constraint "name_of_our_constraint" # # mysql: # 1 column - (IntegrityError) (1062, "Duplicate entry 'value_of_c1' for key # 'c1'") # N columns - (IntegrityError) (1062, "Duplicate entry 'values joined # with -' for key 'name_of_our_constraint'") _DUP_KEY_RE_DB = { "sqlite": (re.compile(r"^.*columns?([^)]+)(is|are)\s+not\s+unique$"), re.compile(r"^.*UNIQUE\s+constraint\s+failed:\s+(.+)$")), "postgresql": (re.compile(r"^.*duplicate\s+key.*\"([^\"]+)\"\s*\n.*$"),), "mysql": (re.compile(r"^.*\(1062,.*'([^\']+)'\"\)$"),) } def _raise_if_duplicate_entry_error(integrity_error, engine_name): """Raise exception if two entries are duplicated. In this function will be raised DBDuplicateEntry exception if integrity error wrap unique constraint violation. """ def get_columns_from_uniq_cons_or_name(columns): # note(vsergeyev): UniqueConstraint name convention: "uniq_t0c10c2" # where `t` it is table name and columns `c1`, `c2` # are in UniqueConstraint. uniqbase = "uniq_" if not columns.startswith(uniqbase): if engine_name == "postgresql": return [columns[columns.index("_") + 1:columns.rindex("_")]] return [columns] return columns[len(uniqbase):].split("0")[1:] if engine_name not in ["mysql", "sqlite", "postgresql"]: return # FIXME(johannes): The usage of the .message attribute has been # deprecated since Python 2.6. However, the exceptions raised by # SQLAlchemy can differ when using unicode() and accessing .message. # An audit across all three supported engines will be necessary to # ensure there are no regressions. for pattern in _DUP_KEY_RE_DB[engine_name]: match = pattern.match(integrity_error.message) if match: break else: return columns = match.group(1) if engine_name == "sqlite": columns = columns.strip().split(", ") else: columns = get_columns_from_uniq_cons_or_name(columns) raise exception.DBDuplicateEntry(columns, integrity_error) # NOTE(comstud): In current versions of DB backends, Deadlock violation # messages follow the structure: # # mysql: # (OperationalError) (1213, 'Deadlock found when trying to get lock; try ' # 'restarting transaction') _DEADLOCK_RE_DB = { "mysql": re.compile(r"^.*\(1213, 'Deadlock.*") } def _raise_if_deadlock_error(operational_error, engine_name): """Raise exception on deadlock condition. Raise DBDeadlock exception if OperationalError contains a Deadlock condition. """ re = _DEADLOCK_RE_DB.get(engine_name) if re is None: return # FIXME(johannes): The usage of the .message attribute has been # deprecated since Python 2.6. However, the exceptions raised by # SQLAlchemy can differ when using unicode() and accessing .message. # An audit across all three supported engines will be necessary to # ensure there are no regressions. m = re.match(operational_error.message) if not m: return raise exception.DBDeadlock(operational_error) def _wrap_db_error(f): @functools.wraps(f) def _wrap(*args, **kwargs): try: return f(*args, **kwargs) except UnicodeEncodeError: raise exception.DBInvalidUnicodeParameter() # note(boris-42): We should catch unique constraint violation and # wrap it by our own DBDuplicateEntry exception. Unique constraint # violation is wrapped by IntegrityError. except sqla_exc.OperationalError as e: _raise_if_deadlock_error(e, get_engine().name) # NOTE(comstud): A lot of code is checking for OperationalError # so let's not wrap it for now. raise except sqla_exc.IntegrityError as e: # note(boris-42): SqlAlchemy doesn't unify errors from different # DBs so we must do this. Also in some tables (for example # instance_types) there are more than one unique constraint. This # means we should get names of columns, which values violate # unique constraint, from error message. _raise_if_duplicate_entry_error(e, get_engine().name) raise exception.DBError(e) except Exception as e: LOG.exception(_('DB exception wrapped.')) raise exception.DBError(e) return _wrap def get_engine(sqlite_fk=False, slave_engine=False, mysql_traditional_mode=False): """Return a SQLAlchemy engine.""" global _ENGINE global _SLAVE_ENGINE engine = _ENGINE db_uri = CONF.database.connection if slave_engine: engine = _SLAVE_ENGINE db_uri = CONF.database.slave_connection if engine is None: engine = create_engine(db_uri, sqlite_fk=sqlite_fk, mysql_traditional_mode=mysql_traditional_mode) if slave_engine: _SLAVE_ENGINE = engine else: _ENGINE = engine return engine def _synchronous_switch_listener(dbapi_conn, connection_rec): """Switch sqlite connections to non-synchronous mode.""" dbapi_conn.execute("PRAGMA synchronous = OFF") def _add_regexp_listener(dbapi_con, con_record): """Add REGEXP function to sqlite connections.""" def regexp(expr, item): reg = re.compile(expr) return reg.search(six.text_type(item)) is not None dbapi_con.create_function('regexp', 2, regexp) def _thread_yield(dbapi_con, con_record): """Ensure other greenthreads get a chance to be executed. If we use eventlet.monkey_patch(), eventlet.greenthread.sleep(0) will execute instead of time.sleep(0). Force a context switch. With common database backends (eg MySQLdb and sqlite), there is no implicit yield caused by network I/O since they are implemented by C libraries that eventlet cannot monkey patch. """ time.sleep(0) def _ping_listener(engine, dbapi_conn, connection_rec, connection_proxy): """Ensures that MySQL and DB2 connections are alive. Borrowed from: http://groups.google.com/group/sqlalchemy/msg/a4ce563d802c929f """ cursor = dbapi_conn.cursor() try: ping_sql = 'select 1' if engine.name == 'ibm_db_sa': # DB2 requires a table expression ping_sql = 'select 1 from (values (1)) AS t1' cursor.execute(ping_sql) except Exception as ex: if engine.dialect.is_disconnect(ex, dbapi_conn, cursor): msg = _('Database server has gone away: %s') % ex LOG.warning(msg) raise sqla_exc.DisconnectionError(msg) else: raise def _set_mode_traditional(dbapi_con, connection_rec, connection_proxy): """Set engine mode to 'traditional'. Required to prevent silent truncates at insert or update operations under MySQL. By default MySQL truncates inserted string if it longer than a declared field just with warning. That is fraught with data corruption. """ dbapi_con.cursor().execute("SET SESSION sql_mode = TRADITIONAL;") def _is_db_connection_error(args): """Return True if error in connecting to db.""" # NOTE(adam_g): This is currently MySQL specific and needs to be extended # to support Postgres and others. # For the db2, the error code is -30081 since the db2 is still not ready conn_err_codes = ('2002', '2003', '2006', '2013', '-30081') for err_code in conn_err_codes: if args.find(err_code) != -1: return True return False def create_engine(sql_connection, sqlite_fk=False, mysql_traditional_mode=False): """Return a new SQLAlchemy engine.""" # NOTE(geekinutah): At this point we could be connecting to the normal # db handle or the slave db handle. Things like # _wrap_db_error aren't going to work well if their # backends don't match. Let's check. _assert_matching_drivers() connection_dict = sqlalchemy.engine.url.make_url(sql_connection) engine_args = { "pool_recycle": CONF.database.idle_timeout, "echo": False, 'convert_unicode': True, } # Map our SQL debug level to SQLAlchemy's options if CONF.database.connection_debug >= 100: engine_args['echo'] = 'debug' elif CONF.database.connection_debug >= 50: engine_args['echo'] = True if "sqlite" in connection_dict.drivername: if sqlite_fk: engine_args["listeners"] = [SqliteForeignKeysListener()] engine_args["poolclass"] = NullPool if CONF.database.connection == "sqlite://": engine_args["poolclass"] = StaticPool engine_args["connect_args"] = {'check_same_thread': False} else: if CONF.database.max_pool_size is not None: engine_args['pool_size'] = CONF.database.max_pool_size if CONF.database.max_overflow is not None: engine_args['max_overflow'] = CONF.database.max_overflow if CONF.database.pool_timeout is not None: engine_args['pool_timeout'] = CONF.database.pool_timeout engine = sqlalchemy.create_engine(sql_connection, **engine_args) sqlalchemy.event.listen(engine, 'checkin', _thread_yield) if engine.name in ['mysql', 'ibm_db_sa']: callback = functools.partial(_ping_listener, engine) sqlalchemy.event.listen(engine, 'checkout', callback) if mysql_traditional_mode: sqlalchemy.event.listen(engine, 'checkout', _set_mode_traditional) else: LOG.warning(_("This application has not enabled MySQL traditional" " mode, which means silent data corruption may" " occur. Please encourage the application" " developers to enable this mode.")) elif 'sqlite' in connection_dict.drivername: if not CONF.sqlite_synchronous: sqlalchemy.event.listen(engine, 'connect', _synchronous_switch_listener) sqlalchemy.event.listen(engine, 'connect', _add_regexp_listener) if (CONF.database.connection_trace and engine.dialect.dbapi.__name__ == 'MySQLdb'): _patch_mysqldb_with_stacktrace_comments() try: engine.connect() except sqla_exc.OperationalError as e: if not _is_db_connection_error(e.args[0]): raise remaining = CONF.database.max_retries if remaining == -1: remaining = 'infinite' while True: msg = _('SQL connection failed. %s attempts left.') LOG.warning(msg % remaining) if remaining != 'infinite': remaining -= 1 time.sleep(CONF.database.retry_interval) try: engine.connect() break except sqla_exc.OperationalError as e: if (remaining != 'infinite' and remaining == 0) or \ not _is_db_connection_error(e.args[0]): raise return engine class Query(sqlalchemy.orm.query.Query): """Subclass of sqlalchemy.query with soft_delete() method.""" def soft_delete(self, synchronize_session='evaluate'): return self.update({'deleted': literal_column('id'), 'updated_at': literal_column('updated_at'), 'deleted_at': timeutils.utcnow()}, synchronize_session=synchronize_session) class Session(sqlalchemy.orm.session.Session): """Custom Session class to avoid SqlAlchemy Session monkey patching.""" @_wrap_db_error def query(self, *args, **kwargs): return super(Session, self).query(*args, **kwargs) @_wrap_db_error def flush(self, *args, **kwargs): return super(Session, self).flush(*args, **kwargs) @_wrap_db_error def execute(self, *args, **kwargs): return super(Session, self).execute(*args, **kwargs) def get_maker(engine, autocommit=True, expire_on_commit=False): """Return a SQLAlchemy sessionmaker using the given engine.""" return sqlalchemy.orm.sessionmaker(bind=engine, class_=Session, autocommit=autocommit, expire_on_commit=expire_on_commit, query_cls=Query) def _patch_mysqldb_with_stacktrace_comments(): """Adds current stack trace as a comment in queries. Patches MySQLdb.cursors.BaseCursor._do_query. """ import MySQLdb.cursors import traceback old_mysql_do_query = MySQLdb.cursors.BaseCursor._do_query def _do_query(self, q): stack = '' for filename, line, method, function in traceback.extract_stack(): # exclude various common things from trace if filename.endswith('session.py') and method == '_do_query': continue if filename.endswith('api.py') and method == 'wrapper': continue if filename.endswith('utils.py') and method == '_inner': continue if filename.endswith('exception.py') and method == '_wrap': continue # db/api is just a wrapper around db/sqlalchemy/api if filename.endswith('db/api.py'): continue # only trace inside heat index = filename.rfind('heat') if index == -1: continue stack += "File:%s:%s Method:%s() Line:%s | " \ % (filename[index:], line, method, function) # strip trailing " | " from stack if stack: stack = stack[:-3] qq = "%s /* %s */" % (q, stack) else: qq = q old_mysql_do_query(self, qq) setattr(MySQLdb.cursors.BaseCursor, '_do_query', _do_query) def _assert_matching_drivers(): """Make sure slave handle and normal handle have the same driver.""" # NOTE(geekinutah): There's no use case for writing to one backend and # reading from another. Who knows what the future holds? if CONF.database.slave_connection == '': return normal = sqlalchemy.engine.url.make_url(CONF.database.connection) slave = sqlalchemy.engine.url.make_url(CONF.database.slave_connection) assert normal.drivername == slave.drivername heat-2014.1.5/heat/openstack/common/db/sqlalchemy/__init__.py0000664000567000056700000000000012540642614025057 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/db/sqlalchemy/test_migrations.py0000664000567000056700000002763412540642614026561 0ustar jenkinsjenkins00000000000000# Copyright 2010-2011 OpenStack Foundation # Copyright 2012-2013 IBM Corp. # 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. import functools import os import subprocess import lockfile from six import moves import sqlalchemy import sqlalchemy.exc from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils from heat.openstack.common import test LOG = logging.getLogger(__name__) def _get_connect_string(backend, user, passwd, database): """Get database connection Try to get a connection with a very specific set of values, if we get these then we'll run the tests, otherwise they are skipped """ if backend == "postgres": backend = "postgresql+psycopg2" elif backend == "mysql": backend = "mysql+mysqldb" else: raise Exception("Unrecognized backend: '%s'" % backend) return ("%(backend)s://%(user)s:%(passwd)s@localhost/%(database)s" % {'backend': backend, 'user': user, 'passwd': passwd, 'database': database}) def _is_backend_avail(backend, user, passwd, database): try: connect_uri = _get_connect_string(backend, user, passwd, database) engine = sqlalchemy.create_engine(connect_uri) connection = engine.connect() except Exception: # intentionally catch all to handle exceptions even if we don't # have any backend code loaded. return False else: connection.close() engine.dispose() return True def _have_mysql(user, passwd, database): present = os.environ.get('TEST_MYSQL_PRESENT') if present is None: return _is_backend_avail('mysql', user, passwd, database) return present.lower() in ('', 'true') def _have_postgresql(user, passwd, database): present = os.environ.get('TEST_POSTGRESQL_PRESENT') if present is None: return _is_backend_avail('postgres', user, passwd, database) return present.lower() in ('', 'true') def get_db_connection_info(conn_pieces): database = conn_pieces.path.strip('/') loc_pieces = conn_pieces.netloc.split('@') host = loc_pieces[1] auth_pieces = loc_pieces[0].split(':') user = auth_pieces[0] password = "" if len(auth_pieces) > 1: password = auth_pieces[1].strip() return (user, password, database, host) def _set_db_lock(lock_path=None, lock_prefix=None): def decorator(f): @functools.wraps(f) def wrapper(*args, **kwargs): try: path = lock_path or os.environ.get("HEAT_LOCK_PATH") lock = lockfile.FileLock(os.path.join(path, lock_prefix)) with lock: LOG.debug(_('Got lock "%s"') % f.__name__) return f(*args, **kwargs) finally: LOG.debug(_('Lock released "%s"') % f.__name__) return wrapper return decorator class BaseMigrationTestCase(test.BaseTestCase): """Base class fort testing of migration utils.""" def __init__(self, *args, **kwargs): super(BaseMigrationTestCase, self).__init__(*args, **kwargs) self.DEFAULT_CONFIG_FILE = os.path.join(os.path.dirname(__file__), 'test_migrations.conf') # Test machines can set the TEST_MIGRATIONS_CONF variable # to override the location of the config file for migration testing self.CONFIG_FILE_PATH = os.environ.get('TEST_MIGRATIONS_CONF', self.DEFAULT_CONFIG_FILE) self.test_databases = {} self.migration_api = None def setUp(self): super(BaseMigrationTestCase, self).setUp() # Load test databases from the config file. Only do this # once. No need to re-run this on each test... LOG.debug('config_path is %s' % self.CONFIG_FILE_PATH) if os.path.exists(self.CONFIG_FILE_PATH): cp = moves.configparser.RawConfigParser() try: cp.read(self.CONFIG_FILE_PATH) defaults = cp.defaults() for key, value in defaults.items(): self.test_databases[key] = value except moves.configparser.ParsingError as e: self.fail("Failed to read test_migrations.conf config " "file. Got error: %s" % e) else: self.fail("Failed to find test_migrations.conf config " "file.") self.engines = {} for key, value in self.test_databases.items(): self.engines[key] = sqlalchemy.create_engine(value) # We start each test case with a completely blank slate. self._reset_databases() def tearDown(self): # We destroy the test data store between each test case, # and recreate it, which ensures that we have no side-effects # from the tests self._reset_databases() super(BaseMigrationTestCase, self).tearDown() def execute_cmd(self, cmd=None): process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) output = process.communicate()[0] LOG.debug(output) self.assertEqual(0, process.returncode, "Failed to run: %s\n%s" % (cmd, output)) def _reset_pg(self, conn_pieces): (user, password, database, host) = get_db_connection_info(conn_pieces) os.environ['PGPASSWORD'] = password os.environ['PGUSER'] = user # note(boris-42): We must create and drop database, we can't # drop database which we have connected to, so for such # operations there is a special database template1. sqlcmd = ("psql -w -U %(user)s -h %(host)s -c" " '%(sql)s' -d template1") sql = ("drop database if exists %s;") % database droptable = sqlcmd % {'user': user, 'host': host, 'sql': sql} self.execute_cmd(droptable) sql = ("create database %s;") % database createtable = sqlcmd % {'user': user, 'host': host, 'sql': sql} self.execute_cmd(createtable) os.unsetenv('PGPASSWORD') os.unsetenv('PGUSER') @_set_db_lock(lock_prefix='migration_tests-') def _reset_databases(self): for key, engine in self.engines.items(): conn_string = self.test_databases[key] conn_pieces = urlutils.urlparse(conn_string) engine.dispose() if conn_string.startswith('sqlite'): # We can just delete the SQLite database, which is # the easiest and cleanest solution db_path = conn_pieces.path.strip('/') if os.path.exists(db_path): os.unlink(db_path) # No need to recreate the SQLite DB. SQLite will # create it for us if it's not there... elif conn_string.startswith('mysql'): # We can execute the MySQL client to destroy and re-create # the MYSQL database, which is easier and less error-prone # than using SQLAlchemy to do this via MetaData...trust me. (user, password, database, host) = \ get_db_connection_info(conn_pieces) sql = ("drop database if exists %(db)s; " "create database %(db)s;") % {'db': database} cmd = ("mysql -u \"%(user)s\" -p\"%(password)s\" -h %(host)s " "-e \"%(sql)s\"") % {'user': user, 'password': password, 'host': host, 'sql': sql} self.execute_cmd(cmd) elif conn_string.startswith('postgresql'): self._reset_pg(conn_pieces) class WalkVersionsMixin(object): def _walk_versions(self, engine=None, snake_walk=False, downgrade=True): # Determine latest version script from the repo, then # upgrade from 1 through to the latest, with no data # in the databases. This just checks that the schema itself # upgrades successfully. # Place the database under version control self.migration_api.version_control(engine, self.REPOSITORY, self.INIT_VERSION) self.assertEqual(self.INIT_VERSION, self.migration_api.db_version(engine, self.REPOSITORY)) LOG.debug('latest version is %s' % self.REPOSITORY.latest) versions = range(self.INIT_VERSION + 1, self.REPOSITORY.latest + 1) for version in versions: # upgrade -> downgrade -> upgrade self._migrate_up(engine, version, with_data=True) if snake_walk: downgraded = self._migrate_down( engine, version - 1, with_data=True) if downgraded: self._migrate_up(engine, version) if downgrade: # Now walk it back down to 0 from the latest, testing # the downgrade paths. for version in reversed(versions): # downgrade -> upgrade -> downgrade downgraded = self._migrate_down(engine, version - 1) if snake_walk and downgraded: self._migrate_up(engine, version) self._migrate_down(engine, version - 1) def _migrate_down(self, engine, version, with_data=False): try: self.migration_api.downgrade(engine, self.REPOSITORY, version) except NotImplementedError: # NOTE(sirp): some migrations, namely release-level # migrations, don't support a downgrade. return False self.assertEqual( version, self.migration_api.db_version(engine, self.REPOSITORY)) # NOTE(sirp): `version` is what we're downgrading to (i.e. the 'target' # version). So if we have any downgrade checks, they need to be run for # the previous (higher numbered) migration. if with_data: post_downgrade = getattr( self, "_post_downgrade_%03d" % (version + 1), None) if post_downgrade: post_downgrade(engine) return True def _migrate_up(self, engine, version, with_data=False): """migrate up to a new version of the db. We allow for data insertion and post checks at every migration version with special _pre_upgrade_### and _check_### functions in the main test. """ # NOTE(sdague): try block is here because it's impossible to debug # where a failed data migration happens otherwise try: if with_data: data = None pre_upgrade = getattr( self, "_pre_upgrade_%03d" % version, None) if pre_upgrade: data = pre_upgrade(engine) self.migration_api.upgrade(engine, self.REPOSITORY, version) self.assertEqual(version, self.migration_api.db_version(engine, self.REPOSITORY)) if with_data: check = getattr(self, "_check_%03d" % version, None) if check: check(engine, data) except Exception: LOG.error("Failed to migrate to version %s on engine %s" % (version, engine)) raise heat-2014.1.5/heat/openstack/common/db/sqlalchemy/migration.py0000664000567000056700000002566012540642614025334 0ustar jenkinsjenkins00000000000000# coding: utf-8 # # Copyright (c) 2013 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. # # Base on code in migrate/changeset/databases/sqlite.py which is under # the following license: # # The MIT License # # Copyright (c) 2009 Evan Rosson, Jan Dittberner, Domen Kožar # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import distutils.version as dist_version import os import re import migrate from migrate.changeset import ansisql from migrate.changeset.databases import sqlite from migrate.versioning import util as migrate_util import sqlalchemy from sqlalchemy.schema import UniqueConstraint from heat.openstack.common.db import exception from heat.openstack.common.db.sqlalchemy import session as db_session from heat.openstack.common.gettextutils import _ # noqa @migrate_util.decorator def patched_with_engine(f, *a, **kw): url = a[0] engine = migrate_util.construct_engine(url, **kw) try: kw['engine'] = engine return f(*a, **kw) finally: if isinstance(engine, migrate_util.Engine) and engine is not url: migrate_util.log.debug('Disposing SQLAlchemy engine %s', engine) engine.dispose() # TODO(jkoelker) When migrate 0.7.3 is released and nova depends # on that version or higher, this can be removed MIN_PKG_VERSION = dist_version.StrictVersion('0.7.3') if (not hasattr(migrate, '__version__') or dist_version.StrictVersion(migrate.__version__) < MIN_PKG_VERSION): migrate_util.with_engine = patched_with_engine # NOTE(jkoelker) Delay importing migrate until we are patched from migrate import exceptions as versioning_exceptions from migrate.versioning import api as versioning_api from migrate.versioning.repository import Repository get_engine = db_session.get_engine def _get_unique_constraints(self, table): """Retrieve information about existing unique constraints of the table This feature is needed for _recreate_table() to work properly. Unfortunately, it's not available in sqlalchemy 0.7.x/0.8.x. """ data = table.metadata.bind.execute( """SELECT sql FROM sqlite_master WHERE type='table' AND name=:table_name""", table_name=table.name ).fetchone()[0] UNIQUE_PATTERN = "CONSTRAINT (\w+) UNIQUE \(([^\)]+)\)" return [ UniqueConstraint( *[getattr(table.columns, c.strip(' "')) for c in cols.split(",")], name=name ) for name, cols in re.findall(UNIQUE_PATTERN, data) ] def _recreate_table(self, table, column=None, delta=None, omit_uniques=None): """Recreate the table properly Unlike the corresponding original method of sqlalchemy-migrate this one doesn't drop existing unique constraints when creating a new one. """ table_name = self.preparer.format_table(table) # we remove all indexes so as not to have # problems during copy and re-create for index in table.indexes: index.drop() # reflect existing unique constraints for uc in self._get_unique_constraints(table): table.append_constraint(uc) # omit given unique constraints when creating a new table if required table.constraints = set([ cons for cons in table.constraints if omit_uniques is None or cons.name not in omit_uniques ]) self.append('ALTER TABLE %s RENAME TO migration_tmp' % table_name) self.execute() insertion_string = self._modify_table(table, column, delta) table.create(bind=self.connection) self.append(insertion_string % {'table_name': table_name}) self.execute() self.append('DROP TABLE migration_tmp') self.execute() def _visit_migrate_unique_constraint(self, *p, **k): """Drop the given unique constraint The corresponding original method of sqlalchemy-migrate just raises NotImplemented error """ self.recreate_table(p[0].table, omit_uniques=[p[0].name]) def patch_migrate(): """A workaround for SQLite's inability to alter things SQLite abilities to alter tables are very limited (please read http://www.sqlite.org/lang_altertable.html for more details). E. g. one can't drop a column or a constraint in SQLite. The workaround for this is to recreate the original table omitting the corresponding constraint (or column). sqlalchemy-migrate library has recreate_table() method that implements this workaround, but it does it wrong: - information about unique constraints of a table is not retrieved. So if you have a table with one unique constraint and a migration adding another one you will end up with a table that has only the latter unique constraint, and the former will be lost - dropping of unique constraints is not supported at all The proper way to fix this is to provide a pull-request to sqlalchemy-migrate, but the project seems to be dead. So we can go on with monkey-patching of the lib at least for now. """ # this patch is needed to ensure that recreate_table() doesn't drop # existing unique constraints of the table when creating a new one helper_cls = sqlite.SQLiteHelper helper_cls.recreate_table = _recreate_table helper_cls._get_unique_constraints = _get_unique_constraints # this patch is needed to be able to drop existing unique constraints constraint_cls = sqlite.SQLiteConstraintDropper constraint_cls.visit_migrate_unique_constraint = \ _visit_migrate_unique_constraint constraint_cls.__bases__ = (ansisql.ANSIColumnDropper, sqlite.SQLiteConstraintGenerator) def db_sync(abs_path, version=None, init_version=0, sanity_check=True): """Upgrade or downgrade a database. Function runs the upgrade() or downgrade() functions in change scripts. :param abs_path: Absolute path to migrate repository. :param version: Database will upgrade/downgrade until this version. If None - database will update to the latest available version. :param init_version: Initial database version :param sanity_check: Require schema sanity checking for all tables """ if version is not None: try: version = int(version) except ValueError: raise exception.DbMigrationError( message=_("version should be an integer")) current_version = db_version(abs_path, init_version) repository = _find_migrate_repo(abs_path) if sanity_check: _db_schema_sanity_check() if version is None or version > current_version: return versioning_api.upgrade(get_engine(), repository, version) else: return versioning_api.downgrade(get_engine(), repository, version) def _db_schema_sanity_check(): engine = get_engine() if engine.name == 'mysql': onlyutf8_sql = ('SELECT TABLE_NAME,TABLE_COLLATION ' 'from information_schema.TABLES ' 'where TABLE_SCHEMA=%s and ' 'TABLE_COLLATION NOT LIKE "%%utf8%%"') # NOTE(morganfainberg): exclude the sqlalchemy-migrate and alembic # versioning tables from the tables we need to verify utf8 status on. # Non-standard table names are not supported. EXCLUDED_TABLES = ['migrate_version', 'alembic_version'] table_names = [res[0] for res in engine.execute(onlyutf8_sql, engine.url.database) if res[0].lower() not in EXCLUDED_TABLES] if len(table_names) > 0: raise ValueError(_('Tables "%s" have non utf8 collation, ' 'please make sure all tables are CHARSET=utf8' ) % ','.join(table_names)) def db_version(abs_path, init_version): """Show the current version of the repository. :param abs_path: Absolute path to migrate repository :param version: Initial database version """ repository = _find_migrate_repo(abs_path) try: return versioning_api.db_version(get_engine(), repository) except versioning_exceptions.DatabaseNotControlledError: meta = sqlalchemy.MetaData() engine = get_engine() meta.reflect(bind=engine) tables = meta.tables if len(tables) == 0: db_version_control(abs_path, init_version) return versioning_api.db_version(get_engine(), repository) else: raise exception.DbMigrationError( message=_( "The database is not under version control, but has " "tables. Please stamp the current version of the schema " "manually.")) def db_version_control(abs_path, version=None): """Mark a database as under this repository's version control. Once a database is under version control, schema changes should only be done via change scripts in this repository. :param abs_path: Absolute path to migrate repository :param version: Initial database version """ repository = _find_migrate_repo(abs_path) versioning_api.version_control(get_engine(), repository, version) return version def _find_migrate_repo(abs_path): """Get the project's change script repository :param abs_path: Absolute path to migrate repository """ if not os.path.exists(abs_path): raise exception.DbMigrationError("Path %s not found" % abs_path) return Repository(abs_path) heat-2014.1.5/heat/openstack/common/db/sqlalchemy/utils.py0000664000567000056700000004502012540642614024473 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2010-2011 OpenStack Foundation. # Copyright 2012 Justin Santa Barbara # 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. import re from migrate.changeset import UniqueConstraint import sqlalchemy from sqlalchemy import Boolean from sqlalchemy import CheckConstraint from sqlalchemy import Column from sqlalchemy.engine import reflection from sqlalchemy.ext.compiler import compiles from sqlalchemy import func from sqlalchemy import Index from sqlalchemy import Integer from sqlalchemy import MetaData from sqlalchemy.sql.expression import literal_column from sqlalchemy.sql.expression import UpdateBase from sqlalchemy.sql import select from sqlalchemy import String from sqlalchemy import Table from sqlalchemy.types import NullType from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import timeutils LOG = logging.getLogger(__name__) _DBURL_REGEX = re.compile(r"[^:]+://([^:]+):([^@]+)@.+") def sanitize_db_url(url): match = _DBURL_REGEX.match(url) if match: return '%s****:****%s' % (url[:match.start(1)], url[match.end(2):]) return url class InvalidSortKey(Exception): message = _("Sort key supplied was not valid.") # copy from glance/db/sqlalchemy/api.py def paginate_query(query, model, limit, sort_keys, marker=None, sort_dir=None, sort_dirs=None): """Returns a query with sorting / pagination criteria added. Pagination works by requiring a unique sort_key, specified by sort_keys. (If sort_keys is not unique, then we risk looping through values.) We use the last row in the previous page as the 'marker' for pagination. So we must return values that follow the passed marker in the order. With a single-valued sort_key, this would be easy: sort_key > X. With a compound-values sort_key, (k1, k2, k3) we must do this to repeat the lexicographical ordering: (k1 > X1) or (k1 == X1 && k2 > X2) or (k1 == X1 && k2 == X2 && k3 > X3) We also have to cope with different sort_directions. Typically, the id of the last row is used as the client-facing pagination marker, then the actual marker object must be fetched from the db and passed in to us as marker. :param query: the query object to which we should add paging/sorting :param model: the ORM model class :param limit: maximum number of items to return :param sort_keys: array of attributes by which results should be sorted :param marker: the last item of the previous page; we returns the next results after this value. :param sort_dir: direction in which results should be sorted (asc, desc) :param sort_dirs: per-column array of sort_dirs, corresponding to sort_keys :rtype: sqlalchemy.orm.query.Query :return: The query with sorting/pagination added. """ if 'id' not in sort_keys: # TODO(justinsb): If this ever gives a false-positive, check # the actual primary key, rather than assuming its id LOG.warning(_('Id not in sort_keys; is sort_keys unique?')) assert(not (sort_dir and sort_dirs)) # Default the sort direction to ascending if sort_dirs is None and sort_dir is None: sort_dir = 'asc' # Ensure a per-column sort direction if sort_dirs is None: sort_dirs = [sort_dir for _sort_key in sort_keys] assert(len(sort_dirs) == len(sort_keys)) # Add sorting for current_sort_key, current_sort_dir in zip(sort_keys, sort_dirs): try: sort_dir_func = { 'asc': sqlalchemy.asc, 'desc': sqlalchemy.desc, }[current_sort_dir] except KeyError: raise ValueError(_("Unknown sort direction, " "must be 'desc' or 'asc'")) try: sort_key_attr = getattr(model, current_sort_key) except AttributeError: raise InvalidSortKey() query = query.order_by(sort_dir_func(sort_key_attr)) # Add pagination if marker is not None: marker_values = [] for sort_key in sort_keys: v = getattr(marker, sort_key) marker_values.append(v) # Build up an array of sort criteria as in the docstring criteria_list = [] for i in range(len(sort_keys)): crit_attrs = [] for j in range(i): model_attr = getattr(model, sort_keys[j]) crit_attrs.append((model_attr == marker_values[j])) model_attr = getattr(model, sort_keys[i]) if sort_dirs[i] == 'desc': crit_attrs.append((model_attr < marker_values[i])) else: crit_attrs.append((model_attr > marker_values[i])) criteria = sqlalchemy.sql.and_(*crit_attrs) criteria_list.append(criteria) f = sqlalchemy.sql.or_(*criteria_list) query = query.filter(f) if limit is not None: query = query.limit(limit) return query def get_table(engine, name): """Returns an sqlalchemy table dynamically from db. Needed because the models don't work for us in migrations as models will be far out of sync with the current data. """ metadata = MetaData() metadata.bind = engine return Table(name, metadata, autoload=True) class InsertFromSelect(UpdateBase): """Form the base for `INSERT INTO table (SELECT ... )` statement.""" def __init__(self, table, select): self.table = table self.select = select @compiles(InsertFromSelect) def visit_insert_from_select(element, compiler, **kw): """Form the `INSERT INTO table (SELECT ... )` statement.""" return "INSERT INTO %s %s" % ( compiler.process(element.table, asfrom=True), compiler.process(element.select)) class ColumnError(Exception): """Error raised when no column or an invalid column is found.""" def _get_not_supported_column(col_name_col_instance, column_name): try: column = col_name_col_instance[column_name] except KeyError: msg = _("Please specify column %s in col_name_col_instance " "param. It is required because column has unsupported " "type by sqlite).") raise ColumnError(msg % column_name) if not isinstance(column, Column): msg = _("col_name_col_instance param has wrong type of " "column instance for column %s It should be instance " "of sqlalchemy.Column.") raise ColumnError(msg % column_name) return column def drop_unique_constraint(migrate_engine, table_name, uc_name, *columns, **col_name_col_instance): """Drop unique constraint from table. This method drops UC from table and works for mysql, postgresql and sqlite. In mysql and postgresql we are able to use "alter table" construction. Sqlalchemy doesn't support some sqlite column types and replaces their type with NullType in metadata. We process these columns and replace NullType with the correct column type. :param migrate_engine: sqlalchemy engine :param table_name: name of table that contains uniq constraint. :param uc_name: name of uniq constraint that will be dropped. :param columns: columns that are in uniq constraint. :param col_name_col_instance: contains pair column_name=column_instance. column_instance is instance of Column. These params are required only for columns that have unsupported types by sqlite. For example BigInteger. """ meta = MetaData() meta.bind = migrate_engine t = Table(table_name, meta, autoload=True) if migrate_engine.name == "sqlite": override_cols = [ _get_not_supported_column(col_name_col_instance, col.name) for col in t.columns if isinstance(col.type, NullType) ] for col in override_cols: t.columns.replace(col) uc = UniqueConstraint(*columns, table=t, name=uc_name) uc.drop() def drop_old_duplicate_entries_from_table(migrate_engine, table_name, use_soft_delete, *uc_column_names): """Drop all old rows having the same values for columns in uc_columns. This method drop (or mark ad `deleted` if use_soft_delete is True) old duplicate rows form table with name `table_name`. :param migrate_engine: Sqlalchemy engine :param table_name: Table with duplicates :param use_soft_delete: If True - values will be marked as `deleted`, if False - values will be removed from table :param uc_column_names: Unique constraint columns """ meta = MetaData() meta.bind = migrate_engine table = Table(table_name, meta, autoload=True) columns_for_group_by = [table.c[name] for name in uc_column_names] columns_for_select = [func.max(table.c.id)] columns_for_select.extend(columns_for_group_by) duplicated_rows_select = select(columns_for_select, group_by=columns_for_group_by, having=func.count(table.c.id) > 1) for row in migrate_engine.execute(duplicated_rows_select): # NOTE(boris-42): Do not remove row that has the biggest ID. delete_condition = table.c.id != row[0] is_none = None # workaround for pyflakes delete_condition &= table.c.deleted_at == is_none for name in uc_column_names: delete_condition &= table.c[name] == row[name] rows_to_delete_select = select([table.c.id]).where(delete_condition) for row in migrate_engine.execute(rows_to_delete_select).fetchall(): LOG.info(_("Deleting duplicated row with id: %(id)s from table: " "%(table)s") % dict(id=row[0], table=table_name)) if use_soft_delete: delete_statement = table.update().\ where(delete_condition).\ values({ 'deleted': literal_column('id'), 'updated_at': literal_column('updated_at'), 'deleted_at': timeutils.utcnow() }) else: delete_statement = table.delete().where(delete_condition) migrate_engine.execute(delete_statement) def _get_default_deleted_value(table): if isinstance(table.c.id.type, Integer): return 0 if isinstance(table.c.id.type, String): return "" raise ColumnError(_("Unsupported id columns type")) def _restore_indexes_on_deleted_columns(migrate_engine, table_name, indexes): table = get_table(migrate_engine, table_name) insp = reflection.Inspector.from_engine(migrate_engine) real_indexes = insp.get_indexes(table_name) existing_index_names = dict( [(index['name'], index['column_names']) for index in real_indexes]) # NOTE(boris-42): Restore indexes on `deleted` column for index in indexes: if 'deleted' not in index['column_names']: continue name = index['name'] if name in existing_index_names: column_names = [table.c[c] for c in existing_index_names[name]] old_index = Index(name, *column_names, unique=index["unique"]) old_index.drop(migrate_engine) column_names = [table.c[c] for c in index['column_names']] new_index = Index(index["name"], *column_names, unique=index["unique"]) new_index.create(migrate_engine) def change_deleted_column_type_to_boolean(migrate_engine, table_name, **col_name_col_instance): if migrate_engine.name == "sqlite": return _change_deleted_column_type_to_boolean_sqlite( migrate_engine, table_name, **col_name_col_instance) insp = reflection.Inspector.from_engine(migrate_engine) indexes = insp.get_indexes(table_name) table = get_table(migrate_engine, table_name) old_deleted = Column('old_deleted', Boolean, default=False) old_deleted.create(table, populate_default=False) table.update().\ where(table.c.deleted == table.c.id).\ values(old_deleted=True).\ execute() table.c.deleted.drop() table.c.old_deleted.alter(name="deleted") _restore_indexes_on_deleted_columns(migrate_engine, table_name, indexes) def _change_deleted_column_type_to_boolean_sqlite(migrate_engine, table_name, **col_name_col_instance): insp = reflection.Inspector.from_engine(migrate_engine) table = get_table(migrate_engine, table_name) columns = [] for column in table.columns: column_copy = None if column.name != "deleted": if isinstance(column.type, NullType): column_copy = _get_not_supported_column(col_name_col_instance, column.name) else: column_copy = column.copy() else: column_copy = Column('deleted', Boolean, default=0) columns.append(column_copy) constraints = [constraint.copy() for constraint in table.constraints] meta = table.metadata new_table = Table(table_name + "__tmp__", meta, *(columns + constraints)) new_table.create() indexes = [] for index in insp.get_indexes(table_name): column_names = [new_table.c[c] for c in index['column_names']] indexes.append(Index(index["name"], *column_names, unique=index["unique"])) c_select = [] for c in table.c: if c.name != "deleted": c_select.append(c) else: c_select.append(table.c.deleted == table.c.id) ins = InsertFromSelect(new_table, select(c_select)) migrate_engine.execute(ins) table.drop() [index.create(migrate_engine) for index in indexes] new_table.rename(table_name) new_table.update().\ where(new_table.c.deleted == new_table.c.id).\ values(deleted=True).\ execute() def change_deleted_column_type_to_id_type(migrate_engine, table_name, **col_name_col_instance): if migrate_engine.name == "sqlite": return _change_deleted_column_type_to_id_type_sqlite( migrate_engine, table_name, **col_name_col_instance) insp = reflection.Inspector.from_engine(migrate_engine) indexes = insp.get_indexes(table_name) table = get_table(migrate_engine, table_name) new_deleted = Column('new_deleted', table.c.id.type, default=_get_default_deleted_value(table)) new_deleted.create(table, populate_default=True) deleted = True # workaround for pyflakes table.update().\ where(table.c.deleted == deleted).\ values(new_deleted=table.c.id).\ execute() table.c.deleted.drop() table.c.new_deleted.alter(name="deleted") _restore_indexes_on_deleted_columns(migrate_engine, table_name, indexes) def _change_deleted_column_type_to_id_type_sqlite(migrate_engine, table_name, **col_name_col_instance): # NOTE(boris-42): sqlaclhemy-migrate can't drop column with check # constraints in sqlite DB and our `deleted` column has # 2 check constraints. So there is only one way to remove # these constraints: # 1) Create new table with the same columns, constraints # and indexes. (except deleted column). # 2) Copy all data from old to new table. # 3) Drop old table. # 4) Rename new table to old table name. insp = reflection.Inspector.from_engine(migrate_engine) meta = MetaData(bind=migrate_engine) table = Table(table_name, meta, autoload=True) default_deleted_value = _get_default_deleted_value(table) columns = [] for column in table.columns: column_copy = None if column.name != "deleted": if isinstance(column.type, NullType): column_copy = _get_not_supported_column(col_name_col_instance, column.name) else: column_copy = column.copy() else: column_copy = Column('deleted', table.c.id.type, default=default_deleted_value) columns.append(column_copy) def is_deleted_column_constraint(constraint): # NOTE(boris-42): There is no other way to check is CheckConstraint # associated with deleted column. if not isinstance(constraint, CheckConstraint): return False sqltext = str(constraint.sqltext) return (sqltext.endswith("deleted in (0, 1)") or sqltext.endswith("deleted IN (:deleted_1, :deleted_2)")) constraints = [] for constraint in table.constraints: if not is_deleted_column_constraint(constraint): constraints.append(constraint.copy()) new_table = Table(table_name + "__tmp__", meta, *(columns + constraints)) new_table.create() indexes = [] for index in insp.get_indexes(table_name): column_names = [new_table.c[c] for c in index['column_names']] indexes.append(Index(index["name"], *column_names, unique=index["unique"])) ins = InsertFromSelect(new_table, table.select()) migrate_engine.execute(ins) table.drop() [index.create(migrate_engine) for index in indexes] new_table.rename(table_name) deleted = True # workaround for pyflakes new_table.update().\ where(new_table.c.deleted == deleted).\ values(deleted=new_table.c.id).\ execute() # NOTE(boris-42): Fix value of deleted column: False -> "" or 0. deleted = False # workaround for pyflakes new_table.update().\ where(new_table.c.deleted == deleted).\ values(deleted=default_deleted_value).\ execute() heat-2014.1.5/heat/openstack/common/db/__init__.py0000664000567000056700000000000012540642614022715 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/db/api.py0000664000567000056700000000351512540642614021745 0ustar jenkinsjenkins00000000000000# Copyright (c) 2013 Rackspace Hosting # 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. """Multiple DB API backend support. Supported configuration options: The following two parameters are in the 'database' group: `backend`: DB backend name or full module path to DB backend module. A DB backend module should implement a method named 'get_backend' which takes no arguments. The method can return any object that implements DB API methods. """ from oslo.config import cfg from heat.openstack.common import importutils db_opts = [ cfg.StrOpt('backend', default='sqlalchemy', deprecated_name='db_backend', deprecated_group='DEFAULT', help='The backend to use for db'), ] CONF = cfg.CONF CONF.register_opts(db_opts, 'database') class DBAPI(object): def __init__(self, backend_mapping=None): if backend_mapping is None: backend_mapping = {} backend_name = CONF.database.backend # Import the untranslated name if we don't have a # mapping. backend_path = backend_mapping.get(backend_name, backend_name) backend_mod = importutils.import_module(backend_path) self.__backend = backend_mod.get_backend() def __getattr__(self, key): return getattr(self.__backend, key) heat-2014.1.5/heat/openstack/common/eventlet_backdoor.py0000664000567000056700000001126112540642614024276 0ustar jenkinsjenkins00000000000000# Copyright (c) 2012 OpenStack Foundation. # Administrator of the National Aeronautics and Space Administration. # 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. from __future__ import print_function import errno import gc import os import pprint import socket import sys import traceback import eventlet import eventlet.backdoor import greenlet from oslo.config import cfg from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging help_for_backdoor_port = ( "Acceptable values are 0, , and :, where 0 results " "in listening on a random tcp port number; results in listening " "on the specified port number (and not enabling backdoor if that port " "is in use); and : results in listening on the smallest " "unused port number within the specified range of port numbers. The " "chosen port is displayed in the service's log file.") eventlet_backdoor_opts = [ cfg.StrOpt('backdoor_port', default=None, help="Enable eventlet backdoor. %s" % help_for_backdoor_port) ] CONF = cfg.CONF CONF.register_opts(eventlet_backdoor_opts) LOG = logging.getLogger(__name__) class EventletBackdoorConfigValueError(Exception): def __init__(self, port_range, help_msg, ex): msg = ('Invalid backdoor_port configuration %(range)s: %(ex)s. ' '%(help)s' % {'range': port_range, 'ex': ex, 'help': help_msg}) super(EventletBackdoorConfigValueError, self).__init__(msg) self.port_range = port_range def _dont_use_this(): print("Don't use this, just disconnect instead") def _find_objects(t): return [o for o in gc.get_objects() if isinstance(o, t)] def _print_greenthreads(): for i, gt in enumerate(_find_objects(greenlet.greenlet)): print(i, gt) traceback.print_stack(gt.gr_frame) print() def _print_nativethreads(): for threadId, stack in sys._current_frames().items(): print(threadId) traceback.print_stack(stack) print() def _parse_port_range(port_range): if ':' not in port_range: start, end = port_range, port_range else: start, end = port_range.split(':', 1) try: start, end = int(start), int(end) if end < start: raise ValueError return start, end except ValueError as ex: raise EventletBackdoorConfigValueError(port_range, ex, help_for_backdoor_port) def _listen(host, start_port, end_port, listen_func): try_port = start_port while True: try: return listen_func((host, try_port)) except socket.error as exc: if (exc.errno != errno.EADDRINUSE or try_port >= end_port): raise try_port += 1 def initialize_if_enabled(): backdoor_locals = { 'exit': _dont_use_this, # So we don't exit the entire process 'quit': _dont_use_this, # So we don't exit the entire process 'fo': _find_objects, 'pgt': _print_greenthreads, 'pnt': _print_nativethreads, } if CONF.backdoor_port is None: return None start_port, end_port = _parse_port_range(str(CONF.backdoor_port)) # NOTE(johannes): The standard sys.displayhook will print the value of # the last expression and set it to __builtin__._, which overwrites # the __builtin__._ that gettext sets. Let's switch to using pprint # since it won't interact poorly with gettext, and it's easier to # read the output too. def displayhook(val): if val is not None: pprint.pprint(val) sys.displayhook = displayhook sock = _listen('localhost', start_port, end_port, eventlet.listen) # In the case of backdoor port being zero, a port number is assigned by # listen(). In any case, pull the port number out here. port = sock.getsockname()[1] LOG.info(_('Eventlet backdoor listening on %(port)s for process %(pid)d') % {'port': port, 'pid': os.getpid()}) eventlet.spawn_n(eventlet.backdoor.backdoor_server, sock, locals=backdoor_locals) return port heat-2014.1.5/heat/openstack/common/context.py0000664000567000056700000000701512540642614022272 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. """ Simple class that stores security context information in the web request. Projects should subclass this class if they wish to enhance the request context or provide additional information in their specific WSGI pipeline. """ import itertools import uuid def generate_request_id(): return 'req-%s' % str(uuid.uuid4()) class RequestContext(object): """Helper class to represent useful information about a request context. Stores information about the security context under which the user accesses the system, as well as additional request information. """ user_idt_format = '{user} {tenant} {domain} {user_domain} {p_domain}' def __init__(self, auth_token=None, user=None, tenant=None, domain=None, user_domain=None, project_domain=None, is_admin=False, read_only=False, show_deleted=False, request_id=None, instance_uuid=None): self.auth_token = auth_token self.user = user self.tenant = tenant self.domain = domain self.user_domain = user_domain self.project_domain = project_domain self.is_admin = is_admin self.read_only = read_only self.show_deleted = show_deleted self.instance_uuid = instance_uuid if not request_id: request_id = generate_request_id() self.request_id = request_id def to_dict(self): user_idt = ( self.user_idt_format.format(user=self.user or '-', tenant=self.tenant or '-', domain=self.domain or '-', user_domain=self.user_domain or '-', p_domain=self.project_domain or '-')) return {'user': self.user, 'tenant': self.tenant, 'domain': self.domain, 'user_domain': self.user_domain, 'project_domain': self.project_domain, 'is_admin': self.is_admin, 'read_only': self.read_only, 'show_deleted': self.show_deleted, 'auth_token': self.auth_token, 'request_id': self.request_id, 'instance_uuid': self.instance_uuid, 'user_identity': user_idt} def get_admin_context(show_deleted=False): context = RequestContext(None, tenant=None, is_admin=True, show_deleted=show_deleted) return context def get_context_from_function_and_args(function, args, kwargs): """Find an arg of type RequestContext and return it. This is useful in a couple of decorators where we don't know much about the function we're wrapping. """ for arg in itertools.chain(kwargs.values(), args): if isinstance(arg, RequestContext): return arg return None heat-2014.1.5/heat/openstack/common/gettextutils.py0000664000567000056700000004214712540642614023360 0ustar jenkinsjenkins00000000000000# Copyright 2012 Red Hat, Inc. # Copyright 2013 IBM Corp. # 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. """ gettext for openstack-common modules. Usual usage in an openstack.common module: from heat.openstack.common.gettextutils import _ """ import copy import gettext import locale from logging import handlers import os import re from babel import localedata import six _localedir = os.environ.get('heat'.upper() + '_LOCALEDIR') _t = gettext.translation('heat', localedir=_localedir, fallback=True) _AVAILABLE_LANGUAGES = {} USE_LAZY = False def enable_lazy(): """Convenience function for configuring _() to use lazy gettext Call this at the start of execution to enable the gettextutils._ function to use lazy gettext functionality. This is useful if your project is importing _ directly instead of using the gettextutils.install() way of importing the _ function. """ global USE_LAZY USE_LAZY = True def _(msg): if USE_LAZY: return Message(msg, domain='heat') else: if six.PY3: return _t.gettext(msg) return _t.ugettext(msg) def install(domain, lazy=False): """Install a _() function using the given translation domain. Given a translation domain, install a _() function using gettext's install() function. The main difference from gettext.install() is that we allow overriding the default localedir (e.g. /usr/share/locale) using a translation-domain-specific environment variable (e.g. NOVA_LOCALEDIR). :param domain: the translation domain :param lazy: indicates whether or not to install the lazy _() function. The lazy _() introduces a way to do deferred translation of messages by installing a _ that builds Message objects, instead of strings, which can then be lazily translated into any available locale. """ if lazy: # NOTE(mrodden): Lazy gettext functionality. # # The following introduces a deferred way to do translations on # messages in OpenStack. We override the standard _() function # and % (format string) operation to build Message objects that can # later be translated when we have more information. def _lazy_gettext(msg): """Create and return a Message object. Lazy gettext function for a given domain, it is a factory method for a project/module to get a lazy gettext function for its own translation domain (i.e. nova, glance, cinder, etc.) Message encapsulates a string so that we can translate it later when needed. """ return Message(msg, domain=domain) from six import moves moves.builtins.__dict__['_'] = _lazy_gettext else: localedir = '%s_LOCALEDIR' % domain.upper() if six.PY3: gettext.install(domain, localedir=os.environ.get(localedir)) else: gettext.install(domain, localedir=os.environ.get(localedir), unicode=True) class Message(six.text_type): """A Message object is a unicode object that can be translated. Translation of Message is done explicitly using the translate() method. For all non-translation intents and purposes, a Message is simply unicode, and can be treated as such. """ def __new__(cls, msgid, msgtext=None, params=None, domain='heat', *args): """Create a new Message object. In order for translation to work gettext requires a message ID, this msgid will be used as the base unicode text. It is also possible for the msgid and the base unicode text to be different by passing the msgtext parameter. """ # If the base msgtext is not given, we use the default translation # of the msgid (which is in English) just in case the system locale is # not English, so that the base text will be in that locale by default. if not msgtext: msgtext = Message._translate_msgid(msgid, domain) # We want to initialize the parent unicode with the actual object that # would have been plain unicode if 'Message' was not enabled. msg = super(Message, cls).__new__(cls, msgtext) msg.msgid = msgid msg.domain = domain msg.params = params return msg def translate(self, desired_locale=None): """Translate this message to the desired locale. :param desired_locale: The desired locale to translate the message to, if no locale is provided the message will be translated to the system's default locale. :returns: the translated message in unicode """ translated_message = Message._translate_msgid(self.msgid, self.domain, desired_locale) if self.params is None: # No need for more translation return translated_message # This Message object may have been formatted with one or more # Message objects as substitution arguments, given either as a single # argument, part of a tuple, or as one or more values in a dictionary. # When translating this Message we need to translate those Messages too translated_params = _translate_args(self.params, desired_locale) translated_message = translated_message % translated_params return translated_message @staticmethod def _translate_msgid(msgid, domain, desired_locale=None): if not desired_locale: system_locale = locale.getdefaultlocale() # If the system locale is not available to the runtime use English if not system_locale[0]: desired_locale = 'en_US' else: desired_locale = system_locale[0] locale_dir = os.environ.get(domain.upper() + '_LOCALEDIR') lang = gettext.translation(domain, localedir=locale_dir, languages=[desired_locale], fallback=True) if six.PY3: translator = lang.gettext else: translator = lang.ugettext translated_message = translator(msgid) return translated_message def __mod__(self, other): # When we mod a Message we want the actual operation to be performed # by the parent class (i.e. unicode()), the only thing we do here is # save the original msgid and the parameters in case of a translation params = self._sanitize_mod_params(other) unicode_mod = super(Message, self).__mod__(params) modded = Message(self.msgid, msgtext=unicode_mod, params=params, domain=self.domain) return modded def _sanitize_mod_params(self, other): """Sanitize the object being modded with this Message. - Add support for modding 'None' so translation supports it - Trim the modded object, which can be a large dictionary, to only those keys that would actually be used in a translation - Snapshot the object being modded, in case the message is translated, it will be used as it was when the Message was created """ if other is None: params = (other,) elif isinstance(other, dict): params = self._trim_dictionary_parameters(other) else: params = self._copy_param(other) return params def _trim_dictionary_parameters(self, dict_param): """Return a dict that only has matching entries in the msgid.""" # NOTE(luisg): Here we trim down the dictionary passed as parameters # to avoid carrying a lot of unnecessary weight around in the message # object, for example if someone passes in Message() % locals() but # only some params are used, and additionally we prevent errors for # non-deepcopyable objects by unicoding() them. # Look for %(param) keys in msgid; # Skip %% and deal with the case where % is first character on the line keys = re.findall('(?:[^%]|^)?%\((\w*)\)[a-z]', self.msgid) # If we don't find any %(param) keys but have a %s if not keys and re.findall('(?:[^%]|^)%[a-z]', self.msgid): # Apparently the full dictionary is the parameter params = self._copy_param(dict_param) else: params = {} # Save our existing parameters as defaults to protect # ourselves from losing values if we are called through an # (erroneous) chain that builds a valid Message with # arguments, and then does something like "msg % kwds" # where kwds is an empty dictionary. src = {} if isinstance(self.params, dict): src.update(self.params) src.update(dict_param) for key in keys: params[key] = self._copy_param(src[key]) return params def _copy_param(self, param): try: return copy.deepcopy(param) except TypeError: # Fallback to casting to unicode this will handle the # python code-like objects that can't be deep-copied return six.text_type(param) def __add__(self, other): msg = _('Message objects do not support addition.') raise TypeError(msg) def __radd__(self, other): return self.__add__(other) def __str__(self): # NOTE(luisg): Logging in python 2.6 tries to str() log records, # and it expects specifically a UnicodeError in order to proceed. msg = _('Message objects do not support str() because they may ' 'contain non-ascii characters. ' 'Please use unicode() or translate() instead.') raise UnicodeError(msg) def get_available_languages(domain): """Lists the available languages for the given translation domain. :param domain: the domain to get languages for """ if domain in _AVAILABLE_LANGUAGES: return copy.copy(_AVAILABLE_LANGUAGES[domain]) localedir = '%s_LOCALEDIR' % domain.upper() find = lambda x: gettext.find(domain, localedir=os.environ.get(localedir), languages=[x]) # NOTE(mrodden): en_US should always be available (and first in case # order matters) since our in-line message strings are en_US language_list = ['en_US'] # NOTE(luisg): Babel <1.0 used a function called list(), which was # renamed to locale_identifiers() in >=1.0, the requirements master list # requires >=0.9.6, uncapped, so defensively work with both. We can remove # this check when the master list updates to >=1.0, and update all projects list_identifiers = (getattr(localedata, 'list', None) or getattr(localedata, 'locale_identifiers')) locale_identifiers = list_identifiers() for i in locale_identifiers: if find(i) is not None: language_list.append(i) # NOTE(luisg): Babel>=1.0,<1.3 has a bug where some OpenStack supported # locales (e.g. 'zh_CN', and 'zh_TW') aren't supported even though they # are perfectly legitimate locales: # https://github.com/mitsuhiko/babel/issues/37 # In Babel 1.3 they fixed the bug and they support these locales, but # they are still not explicitly "listed" by locale_identifiers(). # That is why we add the locales here explicitly if necessary so that # they are listed as supported. aliases = {'zh': 'zh_CN', 'zh_Hant_HK': 'zh_HK', 'zh_Hant': 'zh_TW', 'fil': 'tl_PH'} for (locale, alias) in six.iteritems(aliases): if locale in language_list and alias not in language_list: language_list.append(alias) _AVAILABLE_LANGUAGES[domain] = language_list return copy.copy(language_list) def translate(obj, desired_locale=None): """Gets the translated unicode representation of the given object. If the object is not translatable it is returned as-is. If the locale is None the object is translated to the system locale. :param obj: the object to translate :param desired_locale: the locale to translate the message to, if None the default system locale will be used :returns: the translated object in unicode, or the original object if it could not be translated """ message = obj if not isinstance(message, Message): # If the object to translate is not already translatable, # let's first get its unicode representation message = six.text_type(obj) if isinstance(message, Message): # Even after unicoding() we still need to check if we are # running with translatable unicode before translating return message.translate(desired_locale) return obj def _translate_args(args, desired_locale=None): """Translates all the translatable elements of the given arguments object. This method is used for translating the translatable values in method arguments which include values of tuples or dictionaries. If the object is not a tuple or a dictionary the object itself is translated if it is translatable. If the locale is None the object is translated to the system locale. :param args: the args to translate :param desired_locale: the locale to translate the args to, if None the default system locale will be used :returns: a new args object with the translated contents of the original """ if isinstance(args, tuple): return tuple(translate(v, desired_locale) for v in args) if isinstance(args, dict): translated_dict = {} for (k, v) in six.iteritems(args): translated_v = translate(v, desired_locale) translated_dict[k] = translated_v return translated_dict return translate(args, desired_locale) class TranslationHandler(handlers.MemoryHandler): """Handler that translates records before logging them. The TranslationHandler takes a locale and a target logging.Handler object to forward LogRecord objects to after translating them. This handler depends on Message objects being logged, instead of regular strings. The handler can be configured declaratively in the logging.conf as follows: [handlers] keys = translatedlog, translator [handler_translatedlog] class = handlers.WatchedFileHandler args = ('/var/log/api-localized.log',) formatter = context [handler_translator] class = openstack.common.log.TranslationHandler target = translatedlog args = ('zh_CN',) If the specified locale is not available in the system, the handler will log in the default locale. """ def __init__(self, locale=None, target=None): """Initialize a TranslationHandler :param locale: locale to use for translating messages :param target: logging.Handler object to forward LogRecord objects to after translation """ # NOTE(luisg): In order to allow this handler to be a wrapper for # other handlers, such as a FileHandler, and still be able to # configure it using logging.conf, this handler has to extend # MemoryHandler because only the MemoryHandlers' logging.conf # parsing is implemented such that it accepts a target handler. handlers.MemoryHandler.__init__(self, capacity=0, target=target) self.locale = locale def setFormatter(self, fmt): self.target.setFormatter(fmt) def emit(self, record): # We save the message from the original record to restore it # after translation, so other handlers are not affected by this original_msg = record.msg original_args = record.args try: self._translate_and_log_record(record) finally: record.msg = original_msg record.args = original_args def _translate_and_log_record(self, record): record.msg = translate(record.msg, self.locale) # In addition to translating the message, we also need to translate # arguments that were passed to the log method that were not part # of the main message e.g., log.info(_('Some message %s'), this_one)) record.args = _translate_args(record.args, self.locale) self.target.emit(record) heat-2014.1.5/heat/openstack/common/sslutils.py0000664000567000056700000000542712540642614022475 0ustar jenkinsjenkins00000000000000# Copyright 2013 IBM Corp. # # 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. import os import ssl from oslo.config import cfg from heat.openstack.common.gettextutils import _ ssl_opts = [ cfg.StrOpt('ca_file', default=None, help="CA certificate file to use to verify " "connecting clients"), cfg.StrOpt('cert_file', default=None, help="Certificate file to use when starting " "the server securely"), cfg.StrOpt('key_file', default=None, help="Private key file to use when starting " "the server securely"), ] CONF = cfg.CONF CONF.register_opts(ssl_opts, "ssl") def is_enabled(): cert_file = CONF.ssl.cert_file key_file = CONF.ssl.key_file ca_file = CONF.ssl.ca_file use_ssl = cert_file or key_file if cert_file and not os.path.exists(cert_file): raise RuntimeError(_("Unable to find cert_file : %s") % cert_file) if ca_file and not os.path.exists(ca_file): raise RuntimeError(_("Unable to find ca_file : %s") % ca_file) if key_file and not os.path.exists(key_file): raise RuntimeError(_("Unable to find key_file : %s") % key_file) if use_ssl and (not cert_file or not key_file): raise RuntimeError(_("When running server in SSL mode, you must " "specify both a cert_file and key_file " "option value in your configuration file")) return use_ssl def wrap(sock): ssl_kwargs = { 'server_side': True, 'certfile': CONF.ssl.cert_file, 'keyfile': CONF.ssl.key_file, 'cert_reqs': ssl.CERT_NONE, } if CONF.ssl.ca_file: ssl_kwargs['ca_certs'] = CONF.ssl.ca_file ssl_kwargs['cert_reqs'] = ssl.CERT_REQUIRED return ssl.wrap_socket(sock, **ssl_kwargs) _SSL_PROTOCOLS = { "tlsv1": ssl.PROTOCOL_TLSv1, "sslv23": ssl.PROTOCOL_SSLv23, "sslv3": ssl.PROTOCOL_SSLv3 } try: _SSL_PROTOCOLS["sslv2"] = ssl.PROTOCOL_SSLv2 except AttributeError: pass def validate_ssl_version(version): key = version.lower() try: return _SSL_PROTOCOLS[key] except KeyError: raise RuntimeError(_("Invalid SSL version : %s") % version) heat-2014.1.5/heat/openstack/common/crypto/0000775000567000056700000000000012540643116021547 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/crypto/__init__.py0000664000567000056700000000000012540642611023645 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/crypto/utils.py0000664000567000056700000001413312540642614023265 0ustar jenkinsjenkins00000000000000# Copyright 2013 Red Hat, Inc. # # 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. import base64 from Crypto.Hash import HMAC from Crypto import Random from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils class CryptoutilsException(Exception): """Generic Exception for Crypto utilities.""" message = _("An unknown error occurred in crypto utils.") class CipherBlockLengthTooBig(CryptoutilsException): """The block size is too big.""" def __init__(self, requested, permitted): msg = _("Block size of %(given)d is too big, max = %(maximum)d") message = msg % {'given': requested, 'maximum': permitted} super(CryptoutilsException, self).__init__(message) class HKDFOutputLengthTooLong(CryptoutilsException): """The amount of Key Material asked is too much.""" def __init__(self, requested, permitted): msg = _("Length of %(given)d is too long, max = %(maximum)d") message = msg % {'given': requested, 'maximum': permitted} super(CryptoutilsException, self).__init__(message) class HKDF(object): """An HMAC-based Key Derivation Function implementation (RFC5869) This class creates an object that allows to use HKDF to derive keys. """ def __init__(self, hashtype='SHA256'): self.hashfn = importutils.import_module('Crypto.Hash.' + hashtype) self.max_okm_length = 255 * self.hashfn.digest_size def extract(self, ikm, salt=None): """An extract function that can be used to derive a robust key given weak Input Key Material (IKM) which could be a password. Returns a pseudorandom key (of HashLen octets) :param ikm: input keying material (ex a password) :param salt: optional salt value (a non-secret random value) """ if salt is None: salt = '\x00' * self.hashfn.digest_size return HMAC.new(salt, ikm, self.hashfn).digest() def expand(self, prk, info, length): """An expand function that will return arbitrary length output that can be used as keys. Returns a buffer usable as key material. :param prk: a pseudorandom key of at least HashLen octets :param info: optional string (can be a zero-length string) :param length: length of output keying material (<= 255 * HashLen) """ if length > self.max_okm_length: raise HKDFOutputLengthTooLong(length, self.max_okm_length) N = (length + self.hashfn.digest_size - 1) / self.hashfn.digest_size okm = "" tmp = "" for block in range(1, N + 1): tmp = HMAC.new(prk, tmp + info + chr(block), self.hashfn).digest() okm += tmp return okm[:length] MAX_CB_SIZE = 256 class SymmetricCrypto(object): """Symmetric Key Crypto object. This class creates a Symmetric Key Crypto object that can be used to encrypt, decrypt, or sign arbitrary data. :param enctype: Encryption Cipher name (default: AES) :param hashtype: Hash/HMAC type name (default: SHA256) """ def __init__(self, enctype='AES', hashtype='SHA256'): self.cipher = importutils.import_module('Crypto.Cipher.' + enctype) self.hashfn = importutils.import_module('Crypto.Hash.' + hashtype) def new_key(self, size): return Random.new().read(size) def encrypt(self, key, msg, b64encode=True): """Encrypt the provided msg and returns the cyphertext optionally base64 encoded. Uses AES-128-CBC with a Random IV by default. The plaintext is padded to reach blocksize length. The last byte of the block is the length of the padding. The length of the padding does not include the length byte itself. :param key: The Encryption key. :param msg: the plain text. :returns enc: a block of encrypted data. """ iv = Random.new().read(self.cipher.block_size) cipher = self.cipher.new(key, self.cipher.MODE_CBC, iv) # CBC mode requires a fixed block size. Append padding and length of # padding. if self.cipher.block_size > MAX_CB_SIZE: raise CipherBlockLengthTooBig(self.cipher.block_size, MAX_CB_SIZE) r = len(msg) % self.cipher.block_size padlen = self.cipher.block_size - r - 1 msg += '\x00' * padlen msg += chr(padlen) enc = iv + cipher.encrypt(msg) if b64encode: enc = base64.b64encode(enc) return enc def decrypt(self, key, msg, b64decode=True): """Decrypts the provided ciphertext, optionally base64 encoded, and returns the plaintext message, after padding is removed. Uses AES-128-CBC with an IV by default. :param key: The Encryption key. :param msg: the ciphetext, the first block is the IV :returns plain: the plaintext message. """ if b64decode: msg = base64.b64decode(msg) iv = msg[:self.cipher.block_size] cipher = self.cipher.new(key, self.cipher.MODE_CBC, iv) padded = cipher.decrypt(msg[self.cipher.block_size:]) l = ord(padded[-1]) + 1 plain = padded[:-l] return plain def sign(self, key, msg, b64encode=True): """Signs a message string and returns a base64 encoded signature. Uses HMAC-SHA-256 by default. :param key: The Signing key. :param msg: the message to sign. :returns out: a base64 encoded signature. """ h = HMAC.new(key, msg, self.hashfn) out = h.digest() if b64encode: out = base64.b64encode(out) return out heat-2014.1.5/heat/openstack/common/jsonutils.py0000664000567000056700000001506112540642614022640 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2011 Justin Santa Barbara # 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. ''' JSON related utilities. This module provides a few things: 1) A handy function for getting an object down to something that can be JSON serialized. See to_primitive(). 2) Wrappers around loads() and dumps(). The dumps() wrapper will automatically use to_primitive() for you if needed. 3) This sets up anyjson to use the loads() and dumps() wrappers if anyjson is available. ''' import datetime import functools import inspect import itertools import json try: import xmlrpclib except ImportError: # NOTE(jaypipes): xmlrpclib was renamed to xmlrpc.client in Python3 # however the function and object call signatures # remained the same. This whole try/except block should # be removed and replaced with a call to six.moves once # six 1.4.2 is released. See http://bit.ly/1bqrVzu import xmlrpc.client as xmlrpclib import six from heat.openstack.common import gettextutils from heat.openstack.common import importutils from heat.openstack.common import timeutils netaddr = importutils.try_import("netaddr") _nasty_type_tests = [inspect.ismodule, inspect.isclass, inspect.ismethod, inspect.isfunction, inspect.isgeneratorfunction, inspect.isgenerator, inspect.istraceback, inspect.isframe, inspect.iscode, inspect.isbuiltin, inspect.isroutine, inspect.isabstract] _simple_types = (six.string_types + six.integer_types + (type(None), bool, float)) def to_primitive(value, convert_instances=False, convert_datetime=True, level=0, max_depth=3): """Convert a complex object into primitives. Handy for JSON serialization. We can optionally handle instances, but since this is a recursive function, we could have cyclical data structures. To handle cyclical data structures we could track the actual objects visited in a set, but not all objects are hashable. Instead we just track the depth of the object inspections and don't go too deep. Therefore, convert_instances=True is lossy ... be aware. """ # handle obvious types first - order of basic types determined by running # full tests on nova project, resulting in the following counts: # 572754 # 460353 # 379632 # 274610 # 199918 # 114200 # 51817 # 26164 # 6491 # 283 # 19 if isinstance(value, _simple_types): return value if isinstance(value, datetime.datetime): if convert_datetime: return timeutils.strtime(value) else: return value # value of itertools.count doesn't get caught by nasty_type_tests # and results in infinite loop when list(value) is called. if type(value) == itertools.count: return six.text_type(value) # FIXME(vish): Workaround for LP bug 852095. Without this workaround, # tests that raise an exception in a mocked method that # has a @wrap_exception with a notifier will fail. If # we up the dependency to 0.5.4 (when it is released) we # can remove this workaround. if getattr(value, '__module__', None) == 'mox': return 'mock' if level > max_depth: return '?' # The try block may not be necessary after the class check above, # but just in case ... try: recursive = functools.partial(to_primitive, convert_instances=convert_instances, convert_datetime=convert_datetime, level=level, max_depth=max_depth) if isinstance(value, dict): return dict((k, recursive(v)) for k, v in six.iteritems(value)) elif isinstance(value, (list, tuple)): return [recursive(lv) for lv in value] # It's not clear why xmlrpclib created their own DateTime type, but # for our purposes, make it a datetime type which is explicitly # handled if isinstance(value, xmlrpclib.DateTime): value = datetime.datetime(*tuple(value.timetuple())[:6]) if convert_datetime and isinstance(value, datetime.datetime): return timeutils.strtime(value) elif isinstance(value, gettextutils.Message): return value.data elif hasattr(value, 'iteritems'): return recursive(dict(value.iteritems()), level=level + 1) elif hasattr(value, '__iter__'): return recursive(list(value)) elif convert_instances and hasattr(value, '__dict__'): # Likely an instance of something. Watch for cycles. # Ignore class member vars. return recursive(value.__dict__, level=level + 1) elif netaddr and isinstance(value, netaddr.IPAddress): return six.text_type(value) else: if any(test(value) for test in _nasty_type_tests): return six.text_type(value) return value except TypeError: # Class objects are tricky since they may define something like # __iter__ defined but it isn't callable as list(). return six.text_type(value) def dumps(value, default=to_primitive, **kwargs): return json.dumps(value, default=default, **kwargs) def loads(s): return json.loads(s) def load(s): return json.load(s) try: import anyjson except ImportError: pass else: anyjson._modules.append((__name__, 'dumps', TypeError, 'loads', ValueError, 'load')) anyjson.force_implementation(__name__) heat-2014.1.5/heat/openstack/common/timeutils.py0000664000567000056700000001424112540642614022624 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. """ Time related utilities and helper functions. """ import calendar import datetime import time import iso8601 import six # ISO 8601 extended time format with microseconds _ISO8601_TIME_FORMAT_SUBSECOND = '%Y-%m-%dT%H:%M:%S.%f' _ISO8601_TIME_FORMAT = '%Y-%m-%dT%H:%M:%S' PERFECT_TIME_FORMAT = _ISO8601_TIME_FORMAT_SUBSECOND def isotime(at=None, subsecond=False): """Stringify time in ISO 8601 format.""" if not at: at = utcnow() st = at.strftime(_ISO8601_TIME_FORMAT if not subsecond else _ISO8601_TIME_FORMAT_SUBSECOND) tz = at.tzinfo.tzname(None) if at.tzinfo else 'UTC' st += ('Z' if tz == 'UTC' else tz) return st def parse_isotime(timestr): """Parse time from ISO 8601 format.""" try: return iso8601.parse_date(timestr) except iso8601.ParseError as e: raise ValueError(six.text_type(e)) except TypeError as e: raise ValueError(six.text_type(e)) def strtime(at=None, fmt=PERFECT_TIME_FORMAT): """Returns formatted utcnow.""" if not at: at = utcnow() return at.strftime(fmt) def parse_strtime(timestr, fmt=PERFECT_TIME_FORMAT): """Turn a formatted time back into a datetime.""" return datetime.datetime.strptime(timestr, fmt) def normalize_time(timestamp): """Normalize time in arbitrary timezone to UTC naive object.""" offset = timestamp.utcoffset() if offset is None: return timestamp return timestamp.replace(tzinfo=None) - offset def is_older_than(before, seconds): """Return True if before is older than seconds.""" if isinstance(before, six.string_types): before = parse_strtime(before).replace(tzinfo=None) else: before = before.replace(tzinfo=None) return utcnow() - before > datetime.timedelta(seconds=seconds) def is_newer_than(after, seconds): """Return True if after is newer than seconds.""" if isinstance(after, six.string_types): after = parse_strtime(after).replace(tzinfo=None) else: after = after.replace(tzinfo=None) return after - utcnow() > datetime.timedelta(seconds=seconds) def utcnow_ts(): """Timestamp version of our utcnow function.""" if utcnow.override_time is None: # NOTE(kgriffs): This is several times faster # than going through calendar.timegm(...) return int(time.time()) return calendar.timegm(utcnow().timetuple()) def utcnow(): """Overridable version of utils.utcnow.""" if utcnow.override_time: try: return utcnow.override_time.pop(0) except AttributeError: return utcnow.override_time return datetime.datetime.utcnow() def iso8601_from_timestamp(timestamp): """Returns a iso8601 formatted date from timestamp.""" return isotime(datetime.datetime.utcfromtimestamp(timestamp)) utcnow.override_time = None def set_time_override(override_time=None): """Overrides utils.utcnow. Make it return a constant time or a list thereof, one at a time. :param override_time: datetime instance or list thereof. If not given, defaults to the current UTC time. """ utcnow.override_time = override_time or datetime.datetime.utcnow() def advance_time_delta(timedelta): """Advance overridden time using a datetime.timedelta.""" assert(not utcnow.override_time is None) try: for dt in utcnow.override_time: dt += timedelta except TypeError: utcnow.override_time += timedelta def advance_time_seconds(seconds): """Advance overridden time by seconds.""" advance_time_delta(datetime.timedelta(0, seconds)) def clear_time_override(): """Remove the overridden time.""" utcnow.override_time = None def marshall_now(now=None): """Make an rpc-safe datetime with microseconds. Note: tzinfo is stripped, but not required for relative times. """ if not now: now = utcnow() return dict(day=now.day, month=now.month, year=now.year, hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond) def unmarshall_time(tyme): """Unmarshall a datetime dict.""" return datetime.datetime(day=tyme['day'], month=tyme['month'], year=tyme['year'], hour=tyme['hour'], minute=tyme['minute'], second=tyme['second'], microsecond=tyme['microsecond']) def delta_seconds(before, after): """Return the difference between two timing objects. Compute the difference in seconds between two date, time, or datetime objects (as a float, to microsecond resolution). """ delta = after - before return total_seconds(delta) def total_seconds(delta): """Return the total seconds of datetime.timedelta object. Compute total seconds of datetime.timedelta, datetime.timedelta doesn't have method total_seconds in Python2.6, calculate it manually. """ try: return delta.total_seconds() except AttributeError: return ((delta.days * 24 * 3600) + delta.seconds + float(delta.microseconds) / (10 ** 6)) def is_soon(dt, window): """Determines if time is going to happen in the next window seconds. :param dt: the time :param window: minimum seconds to remain to consider the time not soon :return: True if expiration is within the given duration """ soon = (utcnow() + datetime.timedelta(seconds=window)) return normalize_time(dt) <= soon heat-2014.1.5/heat/openstack/common/excutils.py0000664000567000056700000000716712540642614022456 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack Foundation. # Copyright 2012, Red Hat, Inc. # # 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. """ Exception related utilities. """ import logging import sys import time import traceback import six from heat.openstack.common.gettextutils import _ class save_and_reraise_exception(object): """Save current exception, run some code and then re-raise. In some cases the exception context can be cleared, resulting in None being attempted to be re-raised after an exception handler is run. This can happen when eventlet switches greenthreads or when running an exception handler, code raises and catches an exception. In both cases the exception context will be cleared. To work around this, we save the exception state, run handler code, and then re-raise the original exception. If another exception occurs, the saved exception is logged and the new exception is re-raised. In some cases the caller may not want to re-raise the exception, and for those circumstances this context provides a reraise flag that can be used to suppress the exception. For example:: except Exception: with save_and_reraise_exception() as ctxt: decide_if_need_reraise() if not should_be_reraised: ctxt.reraise = False """ def __init__(self): self.reraise = True def __enter__(self): self.type_, self.value, self.tb, = sys.exc_info() return self def __exit__(self, exc_type, exc_val, exc_tb): if exc_type is not None: logging.error(_('Original exception being dropped: %s'), traceback.format_exception(self.type_, self.value, self.tb)) return False if self.reraise: six.reraise(self.type_, self.value, self.tb) def forever_retry_uncaught_exceptions(infunc): def inner_func(*args, **kwargs): last_log_time = 0 last_exc_message = None exc_count = 0 while True: try: return infunc(*args, **kwargs) except Exception as exc: this_exc_message = six.u(str(exc)) if this_exc_message == last_exc_message: exc_count += 1 else: exc_count = 1 # Do not log any more frequently than once a minute unless # the exception message changes cur_time = int(time.time()) if (cur_time - last_log_time > 60 or this_exc_message != last_exc_message): logging.exception( _('Unexpected exception occurred %d time(s)... ' 'retrying.') % exc_count) last_log_time = cur_time last_exc_message = this_exc_message exc_count = 0 # This should be a very rare event. In case it isn't, do # a sleep. time.sleep(1) return inner_func heat-2014.1.5/heat/openstack/common/network_utils.py0000664000567000056700000000517312540642614023522 0ustar jenkinsjenkins00000000000000# Copyright 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. """ Network-related utilities and helper functions. """ from heat.openstack.common.py3kcompat import urlutils def parse_host_port(address, default_port=None): """Interpret a string as a host:port pair. An IPv6 address MUST be escaped if accompanied by a port, because otherwise ambiguity ensues: 2001:db8:85a3::8a2e:370:7334 means both [2001:db8:85a3::8a2e:370:7334] and [2001:db8:85a3::8a2e:370]:7334. >>> parse_host_port('server01:80') ('server01', 80) >>> parse_host_port('server01') ('server01', None) >>> parse_host_port('server01', default_port=1234) ('server01', 1234) >>> parse_host_port('[::1]:80') ('::1', 80) >>> parse_host_port('[::1]') ('::1', None) >>> parse_host_port('[::1]', default_port=1234) ('::1', 1234) >>> parse_host_port('2001:db8:85a3::8a2e:370:7334', default_port=1234) ('2001:db8:85a3::8a2e:370:7334', 1234) """ if address[0] == '[': # Escaped ipv6 _host, _port = address[1:].split(']') host = _host if ':' in _port: port = _port.split(':')[1] else: port = default_port else: if address.count(':') == 1: host, port = address.split(':') else: # 0 means ipv4, >1 means ipv6. # We prohibit unescaped ipv6 addresses with port. host = address port = default_port return (host, None if port is None else int(port)) def urlsplit(url, scheme='', allow_fragments=True): """Parse a URL using urlparse.urlsplit(), splitting query and fragments. This function papers over Python issue9374 when needed. The parameters are the same as urlparse.urlsplit. """ scheme, netloc, path, query, fragment = urlutils.urlsplit( url, scheme, allow_fragments) if allow_fragments and '#' in path: path, fragment = path.split('#', 1) if '?' in path: path, query = path.split('?', 1) return urlutils.SplitResult(scheme, netloc, path, query, fragment) heat-2014.1.5/heat/openstack/common/test.py0000664000567000056700000000470512540642614021570 0ustar jenkinsjenkins00000000000000# Copyright (c) 2013 Hewlett-Packard Development Company, L.P. # 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. """Common utilities used in testing""" import logging import os import fixtures import testtools _TRUE_VALUES = ('True', 'true', '1', 'yes') _LOG_FORMAT = "%(levelname)8s [%(name)s] %(message)s" class BaseTestCase(testtools.TestCase): def setUp(self): super(BaseTestCase, self).setUp() self._set_timeout() self._fake_output() self._fake_logs() self.useFixture(fixtures.NestedTempfile()) self.useFixture(fixtures.TempHomeDir()) def _set_timeout(self): test_timeout = os.environ.get('OS_TEST_TIMEOUT', 0) try: test_timeout = int(test_timeout) except ValueError: # If timeout value is invalid do not set a timeout. test_timeout = 0 if test_timeout > 0: self.useFixture(fixtures.Timeout(test_timeout, gentle=True)) def _fake_output(self): if os.environ.get('OS_STDOUT_CAPTURE') in _TRUE_VALUES: stdout = self.useFixture(fixtures.StringStream('stdout')).stream self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout)) if os.environ.get('OS_STDERR_CAPTURE') in _TRUE_VALUES: stderr = self.useFixture(fixtures.StringStream('stderr')).stream self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr)) def _fake_logs(self): if os.environ.get('OS_DEBUG') in _TRUE_VALUES: level = logging.DEBUG else: level = logging.INFO capture_logs = os.environ.get('OS_LOG_CAPTURE') in _TRUE_VALUES if capture_logs: self.useFixture( fixtures.FakeLogger( format=_LOG_FORMAT, level=level, nuke_handlers=capture_logs, ) ) else: logging.basicConfig(format=_LOG_FORMAT, level=level) heat-2014.1.5/heat/openstack/common/loopingcall.py0000664000567000056700000001100612540642614023104 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2011 Justin Santa Barbara # 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. import sys from eventlet import event from eventlet import greenthread from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import timeutils LOG = logging.getLogger(__name__) class LoopingCallDone(Exception): """Exception to break out and stop a LoopingCall. The poll-function passed to LoopingCall can raise this exception to break out of the loop normally. This is somewhat analogous to StopIteration. An optional return-value can be included as the argument to the exception; this return-value will be returned by LoopingCall.wait() """ def __init__(self, retvalue=True): """:param retvalue: Value that LoopingCall.wait() should return.""" self.retvalue = retvalue class LoopingCallBase(object): def __init__(self, f=None, *args, **kw): self.args = args self.kw = kw self.f = f self._running = False self.done = None def stop(self): self._running = False def wait(self): return self.done.wait() class FixedIntervalLoopingCall(LoopingCallBase): """A fixed interval looping call.""" def start(self, interval, initial_delay=None): self._running = True done = event.Event() def _inner(): if initial_delay: greenthread.sleep(initial_delay) try: while self._running: start = timeutils.utcnow() self.f(*self.args, **self.kw) end = timeutils.utcnow() if not self._running: break delay = interval - timeutils.delta_seconds(start, end) if delay <= 0: LOG.warn(_('task run outlasted interval by %s sec') % -delay) greenthread.sleep(delay if delay > 0 else 0) except LoopingCallDone as e: self.stop() done.send(e.retvalue) except Exception: LOG.exception(_('in fixed duration looping call')) done.send_exception(*sys.exc_info()) return else: done.send(True) self.done = done greenthread.spawn_n(_inner) return self.done # TODO(mikal): this class name is deprecated in Havana and should be removed # in the I release LoopingCall = FixedIntervalLoopingCall class DynamicLoopingCall(LoopingCallBase): """A looping call which sleeps until the next known event. The function called should return how long to sleep for before being called again. """ def start(self, initial_delay=None, periodic_interval_max=None): self._running = True done = event.Event() def _inner(): if initial_delay: greenthread.sleep(initial_delay) try: while self._running: idle = self.f(*self.args, **self.kw) if not self._running: break if periodic_interval_max is not None: idle = min(idle, periodic_interval_max) LOG.debug(_('Dynamic looping call sleeping for %.02f ' 'seconds'), idle) greenthread.sleep(idle) except LoopingCallDone as e: self.stop() done.send(e.retvalue) except Exception: LOG.exception(_('in dynamic looping call')) done.send_exception(*sys.exc_info()) return else: done.send(True) self.done = done greenthread.spawn(_inner) return self.done heat-2014.1.5/heat/openstack/common/notifier/0000775000567000056700000000000012540643116022046 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/notifier/rpc_notifier.py0000664000567000056700000000331412540642614025106 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. from oslo.config import cfg from heat.openstack.common import context as req_context from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import rpc LOG = logging.getLogger(__name__) notification_topic_opt = cfg.ListOpt( 'notification_topics', default=['notifications', ], help='AMQP topic used for OpenStack notifications') CONF = cfg.CONF CONF.register_opt(notification_topic_opt) def notify(context, message): """Sends a notification via RPC.""" if not context: context = req_context.get_admin_context() priority = message.get('priority', CONF.default_notification_level) priority = priority.lower() for topic in CONF.notification_topics: topic = '%s.%s' % (topic, priority) try: rpc.notify(context, topic, message) except Exception: LOG.exception(_("Could not send notification to %(topic)s. " "Payload=%(message)s"), {"topic": topic, "message": message}) heat-2014.1.5/heat/openstack/common/notifier/test_notifier.py0000664000567000056700000000143212540642614025300 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. NOTIFICATIONS = [] def notify(_context, message): """Test notifier, stores notifications in memory for unittests.""" NOTIFICATIONS.append(message) heat-2014.1.5/heat/openstack/common/notifier/list_notifier.py0000664000567000056700000000721412540642614025300 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack LLC. # 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. from oslo.config import cfg from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import log as logging list_notifier_drivers_opt = cfg.MultiStrOpt( 'list_notifier_drivers', default=['heat.openstack.common.notifier.no_op_notifier'], help='List of drivers to send notifications') CONF = cfg.CONF CONF.register_opt(list_notifier_drivers_opt) LOG = logging.getLogger(__name__) drivers = None class ImportFailureNotifier(object): """Noisily re-raises some exception over-and-over when notify is called.""" def __init__(self, exception): self.exception = exception def notify(self, context, message): raise self.exception def _get_drivers(): """Instantiates and returns drivers based on the flag values.""" global drivers if drivers is None: drivers = [] for notification_driver in CONF.list_notifier_drivers: try: drivers.append(importutils.import_module(notification_driver)) except ImportError as e: drivers.append(ImportFailureNotifier(e)) return drivers def add_driver(notification_driver): """Add a notification driver at runtime.""" # Make sure the driver list is initialized. _get_drivers() if isinstance(notification_driver, basestring): # Load and add try: drivers.append(importutils.import_module(notification_driver)) except ImportError as e: drivers.append(ImportFailureNotifier(e)) else: # Driver is already loaded; just add the object. drivers.append(notification_driver) def _object_name(obj): name = [] if hasattr(obj, '__module__'): name.append(obj.__module__) if hasattr(obj, '__name__'): name.append(obj.__name__) else: name.append(obj.__class__.__name__) return '.'.join(name) def remove_driver(notification_driver): """Remove a notification driver at runtime.""" # Make sure the driver list is initialized. _get_drivers() removed = False if notification_driver in drivers: # We're removing an object. Easy. drivers.remove(notification_driver) removed = True else: # We're removing a driver by name. Search for it. for driver in drivers: if _object_name(driver) == notification_driver: drivers.remove(driver) removed = True if not removed: raise ValueError("Cannot remove; %s is not in list" % notification_driver) def notify(context, message): """Passes notification to multiple notifiers in a list.""" for driver in _get_drivers(): try: driver.notify(context, message) except Exception as e: LOG.exception(_("Problem '%(e)s' attempting to send to " "notification driver %(driver)s."), locals()) def _reset_drivers(): """Used by unit tests to reset the drivers.""" global drivers drivers = None heat-2014.1.5/heat/openstack/common/notifier/log_notifier.py0000664000567000056700000000234412540642614025105 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. from oslo.config import cfg from heat.openstack.common import jsonutils from heat.openstack.common import log as logging CONF = cfg.CONF def notify(_context, message): """Notifies the recipient of the desired event given the model. Log notifications using OpenStack's default logging system. """ priority = message.get('priority', CONF.default_notification_level) priority = priority.lower() logger = logging.getLogger( 'heat.openstack.common.notification.%s' % message['event_type']) getattr(logger, priority)(jsonutils.dumps(message)) heat-2014.1.5/heat/openstack/common/notifier/__init__.py0000664000567000056700000000000012540642614024147 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/notifier/api.py0000664000567000056700000001256712540642614023206 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. import socket import uuid from oslo.config import cfg from heat.openstack.common import context from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import jsonutils from heat.openstack.common import log as logging from heat.openstack.common import timeutils LOG = logging.getLogger(__name__) notifier_opts = [ cfg.MultiStrOpt('notification_driver', default=[], help='Driver or drivers to handle sending notifications'), cfg.StrOpt('default_notification_level', default='INFO', help='Default notification level for outgoing notifications'), cfg.StrOpt('default_publisher_id', default=None, help='Default publisher_id for outgoing notifications'), ] CONF = cfg.CONF CONF.register_opts(notifier_opts) WARN = 'WARN' INFO = 'INFO' ERROR = 'ERROR' CRITICAL = 'CRITICAL' DEBUG = 'DEBUG' log_levels = (DEBUG, WARN, INFO, ERROR, CRITICAL) class BadPriorityException(Exception): pass def notify_decorator(name, fn): """Decorator for notify which is used from utils.monkey_patch(). :param name: name of the function :param function: - object of the function :returns: function -- decorated function """ def wrapped_func(*args, **kwarg): body = {} body['args'] = [] body['kwarg'] = {} for arg in args: body['args'].append(arg) for key in kwarg: body['kwarg'][key] = kwarg[key] ctxt = context.get_context_from_function_and_args(fn, args, kwarg) notify(ctxt, CONF.default_publisher_id or socket.gethostname(), name, CONF.default_notification_level, body) return fn(*args, **kwarg) return wrapped_func def publisher_id(service, host=None): if not host: try: host = CONF.host except AttributeError: host = CONF.default_publisher_id or socket.gethostname() return "%s.%s" % (service, host) def notify(context, publisher_id, event_type, priority, payload): """Sends a notification using the specified driver :param publisher_id: the source worker_type.host of the message :param event_type: the literal type of event (ex. Instance Creation) :param priority: patterned after the enumeration of Python logging levels in the set (DEBUG, WARN, INFO, ERROR, CRITICAL) :param payload: A python dictionary of attributes Outgoing message format includes the above parameters, and appends the following: message_id a UUID representing the id for this notification timestamp the GMT timestamp the notification was sent at The composite message will be constructed as a dictionary of the above attributes, which will then be sent via the transport mechanism defined by the driver. Message example:: {'message_id': str(uuid.uuid4()), 'publisher_id': 'compute.host1', 'timestamp': timeutils.utcnow(), 'priority': 'WARN', 'event_type': 'compute.create_instance', 'payload': {'instance_id': 12, ... }} """ if priority not in log_levels: raise BadPriorityException( _('%s not in valid priorities') % priority) # Ensure everything is JSON serializable. payload = jsonutils.to_primitive(payload, convert_instances=True) msg = dict(message_id=str(uuid.uuid4()), publisher_id=publisher_id, event_type=event_type, priority=priority, payload=payload, timestamp=str(timeutils.utcnow())) for driver in _get_drivers(): try: driver.notify(context, msg) except Exception as e: LOG.exception(_("Problem '%(e)s' attempting to " "send to notification system. " "Payload=%(payload)s") % dict(e=e, payload=payload)) _drivers = None def _get_drivers(): """Instantiate, cache, and return drivers based on the CONF.""" global _drivers if _drivers is None: _drivers = {} for notification_driver in CONF.notification_driver: try: driver = importutils.import_module(notification_driver) _drivers[notification_driver] = driver except ImportError: LOG.exception(_("Failed to load notifier %s. " "These notifications will not be sent.") % notification_driver) return _drivers.values() def _reset_drivers(): """Used by unit tests to reset the drivers.""" global _drivers _drivers = None heat-2014.1.5/heat/openstack/common/notifier/rpc_notifier2.py0000664000567000056700000000365312540642614025176 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. '''messaging based notification driver, with message envelopes''' from oslo.config import cfg from heat.openstack.common import context as req_context from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import rpc LOG = logging.getLogger(__name__) notification_topic_opt = cfg.ListOpt( 'topics', default=['notifications', ], help='AMQP topic(s) used for OpenStack notifications') opt_group = cfg.OptGroup(name='rpc_notifier2', title='Options for rpc_notifier2') CONF = cfg.CONF CONF.register_group(opt_group) CONF.register_opt(notification_topic_opt, opt_group) def notify(context, message): """Sends a notification via RPC.""" if not context: context = req_context.get_admin_context() priority = message.get('priority', CONF.default_notification_level) priority = priority.lower() for topic in CONF.rpc_notifier2.topics: topic = '%s.%s' % (topic, priority) try: rpc.notify(context, topic, message, envelope=True) except Exception: LOG.exception(_("Could not send notification to %(topic)s. " "Payload=%(message)s"), {"topic": topic, "message": message}) heat-2014.1.5/heat/openstack/common/notifier/no_op_notifier.py0000664000567000056700000000135512540642614025437 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. def notify(_context, message): """Notifies the recipient of the desired event given the model.""" pass heat-2014.1.5/heat/openstack/common/notifier/proxy.py0000664000567000056700000000474412540642614023614 0ustar jenkinsjenkins00000000000000# Copyright 2013 Red Hat, Inc. # # 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. """ A temporary helper which emulates heat.messaging.Notifier. This helper method allows us to do the tedious porting to the new Notifier API as a standalone commit so that the commit which switches us to heat.messaging is smaller and easier to review. This file will be removed as part of that commit. """ from oslo.config import cfg from heat.openstack.common.notifier import api as notifier_api CONF = cfg.CONF class Notifier(object): def __init__(self, publisher_id): super(Notifier, self).__init__() self.publisher_id = publisher_id _marker = object() def prepare(self, publisher_id=_marker): ret = self.__class__(self.publisher_id) if publisher_id is not self._marker: ret.publisher_id = publisher_id return ret def _notify(self, ctxt, event_type, payload, priority): notifier_api.notify(ctxt, self.publisher_id, event_type, priority, payload) def audit(self, ctxt, event_type, payload): # No audit in old notifier. self._notify(ctxt, event_type, payload, 'INFO') def debug(self, ctxt, event_type, payload): self._notify(ctxt, event_type, payload, 'DEBUG') def info(self, ctxt, event_type, payload): self._notify(ctxt, event_type, payload, 'INFO') def warn(self, ctxt, event_type, payload): self._notify(ctxt, event_type, payload, 'WARN') warning = warn def error(self, ctxt, event_type, payload): self._notify(ctxt, event_type, payload, 'ERROR') def critical(self, ctxt, event_type, payload): self._notify(ctxt, event_type, payload, 'CRITICAL') def get_notifier(service=None, host=None, publisher_id=None): if not publisher_id: publisher_id = "%s.%s" % (service, host or CONF.host) return Notifier(publisher_id) heat-2014.1.5/heat/openstack/common/notifier/rabbit_notifier.py0000664000567000056700000000207112540642614025564 0ustar jenkinsjenkins00000000000000# Copyright 2012 Red Hat, Inc. # 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. from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.notifier import rpc_notifier LOG = logging.getLogger(__name__) def notify(context, message): """Deprecated in Grizzly. Please use rpc_notifier instead.""" LOG.deprecated(_("The rabbit_notifier is now deprecated." " Please use rpc_notifier instead.")) rpc_notifier.notify(context, message) heat-2014.1.5/heat/openstack/common/policy.py0000664000567000056700000006225512540642614022114 0ustar jenkinsjenkins00000000000000# Copyright (c) 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. """ Common Policy Engine Implementation Policies can be expressed in one of two forms: A list of lists, or a string written in the new policy language. In the list-of-lists representation, each check inside the innermost list is combined as with an "and" conjunction--for that check to pass, all the specified checks must pass. These innermost lists are then combined as with an "or" conjunction. This is the original way of expressing policies, but there now exists a new way: the policy language. In the policy language, each check is specified the same way as in the list-of-lists representation: a simple "a:b" pair that is matched to the correct code to perform that check. However, conjunction operators are available, allowing for more expressiveness in crafting policies. As an example, take the following rule, expressed in the list-of-lists representation:: [["role:admin"], ["project_id:%(project_id)s", "role:projectadmin"]] In the policy language, this becomes:: role:admin or (project_id:%(project_id)s and role:projectadmin) The policy language also has the "not" operator, allowing a richer policy rule:: project_id:%(project_id)s and not role:dunce Finally, two special policy checks should be mentioned; the policy check "@" will always accept an access, and the policy check "!" will always reject an access. (Note that if a rule is either the empty list ("[]") or the empty string, this is equivalent to the "@" policy check.) Of these, the "!" policy check is probably the most useful, as it allows particular rules to be explicitly disabled. """ import abc import re from oslo.config import cfg import six from heat.openstack.common import fileutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import jsonutils from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils policy_opts = [ cfg.StrOpt('policy_file', default='policy.json', help=_('JSON file containing policy')), cfg.StrOpt('policy_default_rule', default='default', help=_('Rule enforced when requested rule is not found')), ] CONF = cfg.CONF CONF.register_opts(policy_opts) LOG = logging.getLogger(__name__) _checks = {} class PolicyNotAuthorized(Exception): def __init__(self, rule): msg = _("Policy doesn't allow %s to be performed.") % rule super(PolicyNotAuthorized, self).__init__(msg) class Rules(dict): """A store for rules. Handles the default_rule setting directly.""" @classmethod def load_json(cls, data, default_rule=None): """Allow loading of JSON rule data.""" # Suck in the JSON data and parse the rules rules = dict((k, parse_rule(v)) for k, v in jsonutils.loads(data).items()) return cls(rules, default_rule) def __init__(self, rules=None, default_rule=None): """Initialize the Rules store.""" super(Rules, self).__init__(rules or {}) self.default_rule = default_rule def __missing__(self, key): """Implements the default rule handling.""" if isinstance(self.default_rule, dict): raise KeyError(key) # If the default rule isn't actually defined, do something # reasonably intelligent if not self.default_rule or self.default_rule not in self: raise KeyError(key) if isinstance(self.default_rule, BaseCheck): return self.default_rule elif isinstance(self.default_rule, six.string_types): return self[self.default_rule] def __str__(self): """Dumps a string representation of the rules.""" # Start by building the canonical strings for the rules out_rules = {} for key, value in self.items(): # Use empty string for singleton TrueCheck instances if isinstance(value, TrueCheck): out_rules[key] = '' else: out_rules[key] = str(value) # Dump a pretty-printed JSON representation return jsonutils.dumps(out_rules, indent=4) class Enforcer(object): """Responsible for loading and enforcing rules. :param policy_file: Custom policy file to use, if none is specified, `CONF.policy_file` will be used. :param rules: Default dictionary / Rules to use. It will be considered just in the first instantiation. If `load_rules(True)`, `clear()` or `set_rules(True)` is called this will be overwritten. :param default_rule: Default rule to use, CONF.default_rule will be used if none is specified. """ def __init__(self, policy_file=None, rules=None, default_rule=None): self.rules = Rules(rules, default_rule) self.default_rule = default_rule or CONF.policy_default_rule self.policy_path = None self.policy_file = policy_file or CONF.policy_file def set_rules(self, rules, overwrite=True): """Create a new Rules object based on the provided dict of rules. :param rules: New rules to use. It should be an instance of dict. :param overwrite: Whether to overwrite current rules or update them with the new rules. """ if not isinstance(rules, dict): raise TypeError(_("Rules must be an instance of dict or Rules, " "got %s instead") % type(rules)) if overwrite: self.rules = Rules(rules, self.default_rule) else: self.rules.update(rules) def clear(self): """Clears Enforcer rules, policy's cache and policy's path.""" self.set_rules({}) self.default_rule = None self.policy_path = None def load_rules(self, force_reload=False): """Loads policy_path's rules. Policy file is cached and will be reloaded if modified. :param force_reload: Whether to overwrite current rules. """ if not self.policy_path: self.policy_path = self._get_policy_path() reloaded, data = fileutils.read_cached_file(self.policy_path, force_reload=force_reload) if reloaded or not self.rules: rules = Rules.load_json(data, self.default_rule) self.set_rules(rules) LOG.debug(_("Rules successfully reloaded")) def _get_policy_path(self): """Locate the policy json data file. :param policy_file: Custom policy file to locate. :returns: The policy path :raises: ConfigFilesNotFoundError if the file couldn't be located. """ policy_file = CONF.find_file(self.policy_file) if policy_file: return policy_file raise cfg.ConfigFilesNotFoundError((self.policy_file,)) def enforce(self, rule, target, creds, do_raise=False, exc=None, *args, **kwargs): """Checks authorization of a rule against the target and credentials. :param rule: A string or BaseCheck instance specifying the rule to evaluate. :param target: As much information about the object being operated on as possible, as a dictionary. :param creds: As much information about the user performing the action as possible, as a dictionary. :param do_raise: Whether to raise an exception or not if check fails. :param exc: Class of the exception to raise if the check fails. Any remaining arguments passed to check() (both positional and keyword arguments) will be passed to the exception class. If not specified, PolicyNotAuthorized will be used. :return: Returns False if the policy does not allow the action and exc is not provided; otherwise, returns a value that evaluates to True. Note: for rules using the "case" expression, this True value will be the specified string from the expression. """ # NOTE(flaper87): Not logging target or creds to avoid # potential security issues. LOG.debug(_("Rule %s will be now enforced") % rule) self.load_rules() # Allow the rule to be a Check tree if isinstance(rule, BaseCheck): result = rule(target, creds, self) elif not self.rules: # No rules to reference means we're going to fail closed result = False else: try: # Evaluate the rule result = self.rules[rule](target, creds, self) except KeyError: LOG.debug(_("Rule [%s] doesn't exist") % rule) # If the rule doesn't exist, fail closed result = False # If it is False, raise the exception if requested if do_raise and not result: if exc: raise exc(*args, **kwargs) raise PolicyNotAuthorized(rule) return result @six.add_metaclass(abc.ABCMeta) class BaseCheck(object): """Abstract base class for Check classes.""" @abc.abstractmethod def __str__(self): """String representation of the Check tree rooted at this node.""" pass @abc.abstractmethod def __call__(self, target, cred, enforcer): """Triggers if instance of the class is called. Performs the check. Returns False to reject the access or a true value (not necessary True) to accept the access. """ pass class FalseCheck(BaseCheck): """A policy check that always returns False (disallow).""" def __str__(self): """Return a string representation of this check.""" return "!" def __call__(self, target, cred, enforcer): """Check the policy.""" return False class TrueCheck(BaseCheck): """A policy check that always returns True (allow).""" def __str__(self): """Return a string representation of this check.""" return "@" def __call__(self, target, cred, enforcer): """Check the policy.""" return True class Check(BaseCheck): """A base class to allow for user-defined policy checks.""" def __init__(self, kind, match): """Initiates Check instance. :param kind: The kind of the check, i.e., the field before the ':'. :param match: The match of the check, i.e., the field after the ':'. """ self.kind = kind self.match = match def __str__(self): """Return a string representation of this check.""" return "%s:%s" % (self.kind, self.match) class NotCheck(BaseCheck): """Implements the "not" logical operator. A policy check that inverts the result of another policy check. """ def __init__(self, rule): """Initialize the 'not' check. :param rule: The rule to negate. Must be a Check. """ self.rule = rule def __str__(self): """Return a string representation of this check.""" return "not %s" % self.rule def __call__(self, target, cred, enforcer): """Check the policy. Returns the logical inverse of the wrapped check. """ return not self.rule(target, cred, enforcer) class AndCheck(BaseCheck): """Implements the "and" logical operator. A policy check that requires that a list of other checks all return True. """ def __init__(self, rules): """Initialize the 'and' check. :param rules: A list of rules that will be tested. """ self.rules = rules def __str__(self): """Return a string representation of this check.""" return "(%s)" % ' and '.join(str(r) for r in self.rules) def __call__(self, target, cred, enforcer): """Check the policy. Requires that all rules accept in order to return True. """ for rule in self.rules: if not rule(target, cred, enforcer): return False return True def add_check(self, rule): """Adds rule to be tested. Allows addition of another rule to the list of rules that will be tested. Returns the AndCheck object for convenience. """ self.rules.append(rule) return self class OrCheck(BaseCheck): """Implements the "or" operator. A policy check that requires that at least one of a list of other checks returns True. """ def __init__(self, rules): """Initialize the 'or' check. :param rules: A list of rules that will be tested. """ self.rules = rules def __str__(self): """Return a string representation of this check.""" return "(%s)" % ' or '.join(str(r) for r in self.rules) def __call__(self, target, cred, enforcer): """Check the policy. Requires that at least one rule accept in order to return True. """ for rule in self.rules: if rule(target, cred, enforcer): return True return False def add_check(self, rule): """Adds rule to be tested. Allows addition of another rule to the list of rules that will be tested. Returns the OrCheck object for convenience. """ self.rules.append(rule) return self def _parse_check(rule): """Parse a single base check rule into an appropriate Check object.""" # Handle the special checks if rule == '!': return FalseCheck() elif rule == '@': return TrueCheck() try: kind, match = rule.split(':', 1) except Exception: LOG.exception(_("Failed to understand rule %s") % rule) # If the rule is invalid, we'll fail closed return FalseCheck() # Find what implements the check if kind in _checks: return _checks[kind](kind, match) elif None in _checks: return _checks[None](kind, match) else: LOG.error(_("No handler for matches of kind %s") % kind) return FalseCheck() def _parse_list_rule(rule): """Translates the old list-of-lists syntax into a tree of Check objects. Provided for backwards compatibility. """ # Empty rule defaults to True if not rule: return TrueCheck() # Outer list is joined by "or"; inner list by "and" or_list = [] for inner_rule in rule: # Elide empty inner lists if not inner_rule: continue # Handle bare strings if isinstance(inner_rule, six.string_types): inner_rule = [inner_rule] # Parse the inner rules into Check objects and_list = [_parse_check(r) for r in inner_rule] # Append the appropriate check to the or_list if len(and_list) == 1: or_list.append(and_list[0]) else: or_list.append(AndCheck(and_list)) # If we have only one check, omit the "or" if not or_list: return FalseCheck() elif len(or_list) == 1: return or_list[0] return OrCheck(or_list) # Used for tokenizing the policy language _tokenize_re = re.compile(r'\s+') def _parse_tokenize(rule): """Tokenizer for the policy language. Most of the single-character tokens are specified in the _tokenize_re; however, parentheses need to be handled specially, because they can appear inside a check string. Thankfully, those parentheses that appear inside a check string can never occur at the very beginning or end ("%(variable)s" is the correct syntax). """ for tok in _tokenize_re.split(rule): # Skip empty tokens if not tok or tok.isspace(): continue # Handle leading parens on the token clean = tok.lstrip('(') for i in range(len(tok) - len(clean)): yield '(', '(' # If it was only parentheses, continue if not clean: continue else: tok = clean # Handle trailing parens on the token clean = tok.rstrip(')') trail = len(tok) - len(clean) # Yield the cleaned token lowered = clean.lower() if lowered in ('and', 'or', 'not'): # Special tokens yield lowered, clean elif clean: # Not a special token, but not composed solely of ')' if len(tok) >= 2 and ((tok[0], tok[-1]) in [('"', '"'), ("'", "'")]): # It's a quoted string yield 'string', tok[1:-1] else: yield 'check', _parse_check(clean) # Yield the trailing parens for i in range(trail): yield ')', ')' class ParseStateMeta(type): """Metaclass for the ParseState class. Facilitates identifying reduction methods. """ def __new__(mcs, name, bases, cls_dict): """Create the class. Injects the 'reducers' list, a list of tuples matching token sequences to the names of the corresponding reduction methods. """ reducers = [] for key, value in cls_dict.items(): if not hasattr(value, 'reducers'): continue for reduction in value.reducers: reducers.append((reduction, key)) cls_dict['reducers'] = reducers return super(ParseStateMeta, mcs).__new__(mcs, name, bases, cls_dict) def reducer(*tokens): """Decorator for reduction methods. Arguments are a sequence of tokens, in order, which should trigger running this reduction method. """ def decorator(func): # Make sure we have a list of reducer sequences if not hasattr(func, 'reducers'): func.reducers = [] # Add the tokens to the list of reducer sequences func.reducers.append(list(tokens)) return func return decorator @six.add_metaclass(ParseStateMeta) class ParseState(object): """Implement the core of parsing the policy language. Uses a greedy reduction algorithm to reduce a sequence of tokens into a single terminal, the value of which will be the root of the Check tree. Note: error reporting is rather lacking. The best we can get with this parser formulation is an overall "parse failed" error. Fortunately, the policy language is simple enough that this shouldn't be that big a problem. """ def __init__(self): """Initialize the ParseState.""" self.tokens = [] self.values = [] def reduce(self): """Perform a greedy reduction of the token stream. If a reducer method matches, it will be executed, then the reduce() method will be called recursively to search for any more possible reductions. """ for reduction, methname in self.reducers: if (len(self.tokens) >= len(reduction) and self.tokens[-len(reduction):] == reduction): # Get the reduction method meth = getattr(self, methname) # Reduce the token stream results = meth(*self.values[-len(reduction):]) # Update the tokens and values self.tokens[-len(reduction):] = [r[0] for r in results] self.values[-len(reduction):] = [r[1] for r in results] # Check for any more reductions return self.reduce() def shift(self, tok, value): """Adds one more token to the state. Calls reduce().""" self.tokens.append(tok) self.values.append(value) # Do a greedy reduce... self.reduce() @property def result(self): """Obtain the final result of the parse. Raises ValueError if the parse failed to reduce to a single result. """ if len(self.values) != 1: raise ValueError("Could not parse rule") return self.values[0] @reducer('(', 'check', ')') @reducer('(', 'and_expr', ')') @reducer('(', 'or_expr', ')') def _wrap_check(self, _p1, check, _p2): """Turn parenthesized expressions into a 'check' token.""" return [('check', check)] @reducer('check', 'and', 'check') def _make_and_expr(self, check1, _and, check2): """Create an 'and_expr'. Join two checks by the 'and' operator. """ return [('and_expr', AndCheck([check1, check2]))] @reducer('and_expr', 'and', 'check') def _extend_and_expr(self, and_expr, _and, check): """Extend an 'and_expr' by adding one more check.""" return [('and_expr', and_expr.add_check(check))] @reducer('check', 'or', 'check') def _make_or_expr(self, check1, _or, check2): """Create an 'or_expr'. Join two checks by the 'or' operator. """ return [('or_expr', OrCheck([check1, check2]))] @reducer('or_expr', 'or', 'check') def _extend_or_expr(self, or_expr, _or, check): """Extend an 'or_expr' by adding one more check.""" return [('or_expr', or_expr.add_check(check))] @reducer('not', 'check') def _make_not_expr(self, _not, check): """Invert the result of another check.""" return [('check', NotCheck(check))] def _parse_text_rule(rule): """Parses policy to the tree. Translates a policy written in the policy language into a tree of Check objects. """ # Empty rule means always accept if not rule: return TrueCheck() # Parse the token stream state = ParseState() for tok, value in _parse_tokenize(rule): state.shift(tok, value) try: return state.result except ValueError: # Couldn't parse the rule LOG.exception(_("Failed to understand rule %r") % rule) # Fail closed return FalseCheck() def parse_rule(rule): """Parses a policy rule into a tree of Check objects.""" # If the rule is a string, it's in the policy language if isinstance(rule, six.string_types): return _parse_text_rule(rule) return _parse_list_rule(rule) def register(name, func=None): """Register a function or Check class as a policy check. :param name: Gives the name of the check type, e.g., 'rule', 'role', etc. If name is None, a default check type will be registered. :param func: If given, provides the function or class to register. If not given, returns a function taking one argument to specify the function or class to register, allowing use as a decorator. """ # Perform the actual decoration by registering the function or # class. Returns the function or class for compliance with the # decorator interface. def decorator(func): _checks[name] = func return func # If the function or class is given, do the registration if func: return decorator(func) return decorator @register("rule") class RuleCheck(Check): def __call__(self, target, creds, enforcer): """Recursively checks credentials based on the defined rules.""" try: return enforcer.rules[self.match](target, creds, enforcer) except KeyError: # We don't have any matching rule; fail closed return False @register("role") class RoleCheck(Check): def __call__(self, target, creds, enforcer): """Check that there is a matching role in the cred dict.""" return self.match.lower() in [x.lower() for x in creds['roles']] @register('http') class HttpCheck(Check): def __call__(self, target, creds, enforcer): """Check http: rules by calling to a remote server. This example implementation simply verifies that the response is exactly 'True'. """ url = ('http:' + self.match) % target data = {'target': jsonutils.dumps(target), 'credentials': jsonutils.dumps(creds)} post_data = urlutils.urlencode(data) f = urlutils.urlopen(url, post_data) return f.read() == "True" @register(None) class GenericCheck(Check): def __call__(self, target, creds, enforcer): """Check an individual match. Matches look like: tenant:%(tenant_id)s role:compute:admin """ # TODO(termie): do dict inspection via dot syntax try: match = self.match % target except KeyError: # While doing GenericCheck if key not # present in Target return false return False if self.kind in creds: return match == six.text_type(creds[self.kind]) return False heat-2014.1.5/heat/openstack/common/README0000664000567000056700000000072312540642614021113 0ustar jenkinsjenkins00000000000000openstack-common ---------------- A number of modules from openstack-common are imported into this project. These modules are "incubating" in openstack-common and are kept in sync with the help of openstack-common's update.py script. See: https://wiki.openstack.org/wiki/Oslo#Syncing_Code_from_Incubator The copy of the code should never be directly modified here. Please always update openstack-common first and then run the script to copy the changes across. heat-2014.1.5/heat/openstack/common/log_handler.py0000664000567000056700000000210712540642614023061 0ustar jenkinsjenkins00000000000000# Copyright 2013 IBM Corp. # # 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. import logging from oslo.config import cfg from heat.openstack.common import notifier class PublishErrorsHandler(logging.Handler): def emit(self, record): if ('heat.openstack.common.notifier.log_notifier' in cfg.CONF.notification_driver): return notifier.api.notify(None, 'error.publisher', 'error_notification', notifier.api.ERROR, dict(error=record.msg)) heat-2014.1.5/heat/openstack/common/log.py0000664000567000056700000005366712540642614021405 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack Foundation. # Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # 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. """Openstack logging handler. This module adds to logging functionality by adding the option to specify a context object when calling the various log methods. If the context object is not specified, default formatting is used. Additionally, an instance uuid may be passed as part of the log message, which is intended to make it easier for admins to find messages related to a specific instance. It also allows setting of formatting information through conf. """ import inspect import itertools import logging import logging.config import logging.handlers import os import re import sys import traceback from oslo.config import cfg import six from six import moves from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import jsonutils from heat.openstack.common import local _DEFAULT_LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S" _SANITIZE_KEYS = ['adminPass', 'admin_pass', 'password', 'admin_password'] # NOTE(ldbragst): Let's build a list of regex objects using the list of # _SANITIZE_KEYS we already have. This way, we only have to add the new key # to the list of _SANITIZE_KEYS and we can generate regular expressions # for XML and JSON automatically. _SANITIZE_PATTERNS = [] _FORMAT_PATTERNS = [r'(%(key)s\s*[=]\s*[\"\']).*?([\"\'])', r'(<%(key)s>).*?()', r'([\"\']%(key)s[\"\']\s*:\s*[\"\']).*?([\"\'])', r'([\'"].*?%(key)s[\'"]\s*:\s*u?[\'"]).*?([\'"])'] for key in _SANITIZE_KEYS: for pattern in _FORMAT_PATTERNS: reg_ex = re.compile(pattern % {'key': key}, re.DOTALL) _SANITIZE_PATTERNS.append(reg_ex) common_cli_opts = [ cfg.BoolOpt('debug', short='d', default=False, help='Print debugging output (set logging level to ' 'DEBUG instead of default WARNING level).'), cfg.BoolOpt('verbose', short='v', default=False, help='Print more verbose output (set logging level to ' 'INFO instead of default WARNING level).'), ] logging_cli_opts = [ cfg.StrOpt('log-config-append', metavar='PATH', deprecated_name='log-config', help='The name of logging configuration file. It does not ' 'disable existing loggers, but just appends specified ' 'logging configuration to any other existing logging ' 'options. Please see the Python logging module ' 'documentation for details on logging configuration ' 'files.'), cfg.StrOpt('log-format', default=None, metavar='FORMAT', help='DEPRECATED. ' 'A logging.Formatter log message format string which may ' 'use any of the available logging.LogRecord attributes. ' 'This option is deprecated. Please use ' 'logging_context_format_string and ' 'logging_default_format_string instead.'), cfg.StrOpt('log-date-format', default=_DEFAULT_LOG_DATE_FORMAT, metavar='DATE_FORMAT', help='Format string for %%(asctime)s in log records. ' 'Default: %(default)s'), cfg.StrOpt('log-file', metavar='PATH', deprecated_name='logfile', help='(Optional) Name of log file to output to. ' 'If no default is set, logging will go to stdout.'), cfg.StrOpt('log-dir', deprecated_name='logdir', help='(Optional) The base directory used for relative ' '--log-file paths'), cfg.BoolOpt('use-syslog', default=False, help='Use syslog for logging.'), cfg.StrOpt('syslog-log-facility', default='LOG_USER', help='syslog facility to receive log lines') ] generic_log_opts = [ cfg.BoolOpt('use_stderr', default=True, help='Log output to standard error') ] log_opts = [ cfg.StrOpt('logging_context_format_string', default='%(asctime)s.%(msecs)03d %(process)d %(levelname)s ' '%(name)s [%(request_id)s %(user_identity)s] ' '%(instance)s%(message)s', help='format string to use for log messages with context'), cfg.StrOpt('logging_default_format_string', default='%(asctime)s.%(msecs)03d %(process)d %(levelname)s ' '%(name)s [-] %(instance)s%(message)s', help='format string to use for log messages without context'), cfg.StrOpt('logging_debug_format_suffix', default='%(funcName)s %(pathname)s:%(lineno)d', help='data to append to log format when level is DEBUG'), cfg.StrOpt('logging_exception_prefix', default='%(asctime)s.%(msecs)03d %(process)d TRACE %(name)s ' '%(instance)s', help='prefix each line of exception output with this format'), cfg.ListOpt('default_log_levels', default=[ 'amqp=WARN', 'amqplib=WARN', 'boto=WARN', 'qpid=WARN', 'sqlalchemy=WARN', 'suds=INFO', 'iso8601=WARN', ], help='list of logger=LEVEL pairs'), cfg.BoolOpt('publish_errors', default=False, help='publish error events'), cfg.BoolOpt('fatal_deprecations', default=False, help='make deprecations fatal'), # NOTE(mikal): there are two options here because sometimes we are handed # a full instance (and could include more information), and other times we # are just handed a UUID for the instance. cfg.StrOpt('instance_format', default='[instance: %(uuid)s] ', help='If an instance is passed with the log message, format ' 'it like this'), cfg.StrOpt('instance_uuid_format', default='[instance: %(uuid)s] ', help='If an instance UUID is passed with the log message, ' 'format it like this'), ] CONF = cfg.CONF CONF.register_cli_opts(common_cli_opts) CONF.register_cli_opts(logging_cli_opts) CONF.register_opts(generic_log_opts) CONF.register_opts(log_opts) # our new audit level # NOTE(jkoelker) Since we synthesized an audit level, make the logging # module aware of it so it acts like other levels. logging.AUDIT = logging.INFO + 1 logging.addLevelName(logging.AUDIT, 'AUDIT') try: NullHandler = logging.NullHandler except AttributeError: # NOTE(jkoelker) NullHandler added in Python 2.7 class NullHandler(logging.Handler): def handle(self, record): pass def emit(self, record): pass def createLock(self): self.lock = None def _dictify_context(context): if context is None: return None if not isinstance(context, dict) and getattr(context, 'to_dict', None): context = context.to_dict() return context def _get_binary_name(): return os.path.basename(inspect.stack()[-1][1]) def _get_log_file_path(binary=None): logfile = CONF.log_file logdir = CONF.log_dir if logfile and not logdir: return logfile if logfile and logdir: return os.path.join(logdir, logfile) if logdir: binary = binary or _get_binary_name() return '%s.log' % (os.path.join(logdir, binary),) return None def mask_password(message, secret="***"): """Replace password with 'secret' in message. :param message: The string which includes security information. :param secret: value with which to replace passwords. :returns: The unicode value of message with the password fields masked. For example: >>> mask_password("'adminPass' : 'aaaaa'") "'adminPass' : '***'" >>> mask_password("'admin_pass' : 'aaaaa'") "'admin_pass' : '***'" >>> mask_password('"password" : "aaaaa"') '"password" : "***"' >>> mask_password("'original_password' : 'aaaaa'") "'original_password' : '***'" >>> mask_password("u'original_password' : u'aaaaa'") "u'original_password' : u'***'" """ message = six.text_type(message) # NOTE(ldbragst): Check to see if anything in message contains any key # specified in _SANITIZE_KEYS, if not then just return the message since # we don't have to mask any passwords. if not any(key in message for key in _SANITIZE_KEYS): return message secret = r'\g<1>' + secret + r'\g<2>' for pattern in _SANITIZE_PATTERNS: message = re.sub(pattern, secret, message) return message class BaseLoggerAdapter(logging.LoggerAdapter): def audit(self, msg, *args, **kwargs): self.log(logging.AUDIT, msg, *args, **kwargs) class LazyAdapter(BaseLoggerAdapter): def __init__(self, name='unknown', version='unknown'): self._logger = None self.extra = {} self.name = name self.version = version @property def logger(self): if not self._logger: self._logger = getLogger(self.name, self.version) return self._logger class ContextAdapter(BaseLoggerAdapter): warn = logging.LoggerAdapter.warning def __init__(self, logger, project_name, version_string): self.logger = logger self.project = project_name self.version = version_string @property def handlers(self): return self.logger.handlers def deprecated(self, msg, *args, **kwargs): stdmsg = _("Deprecated: %s") % msg if CONF.fatal_deprecations: self.critical(stdmsg, *args, **kwargs) raise DeprecatedConfig(msg=stdmsg) else: self.warn(stdmsg, *args, **kwargs) def process(self, msg, kwargs): # NOTE(mrodden): catch any Message/other object and # coerce to unicode before they can get # to the python logging and possibly # cause string encoding trouble if not isinstance(msg, six.string_types): msg = six.text_type(msg) if 'extra' not in kwargs: kwargs['extra'] = {} extra = kwargs['extra'] context = kwargs.pop('context', None) if not context: context = getattr(local.store, 'context', None) if context: extra.update(_dictify_context(context)) instance = kwargs.pop('instance', None) instance_uuid = (extra.get('instance_uuid', None) or kwargs.pop('instance_uuid', None)) instance_extra = '' if instance: instance_extra = CONF.instance_format % instance elif instance_uuid: instance_extra = (CONF.instance_uuid_format % {'uuid': instance_uuid}) extra['instance'] = instance_extra extra.setdefault('user_identity', kwargs.pop('user_identity', None)) extra['project'] = self.project extra['version'] = self.version extra['extra'] = extra.copy() return msg, kwargs class JSONFormatter(logging.Formatter): def __init__(self, fmt=None, datefmt=None): # NOTE(jkoelker) we ignore the fmt argument, but its still there # since logging.config.fileConfig passes it. self.datefmt = datefmt def formatException(self, ei, strip_newlines=True): lines = traceback.format_exception(*ei) if strip_newlines: lines = [moves.filter( lambda x: x, line.rstrip().splitlines()) for line in lines] lines = list(itertools.chain(*lines)) return lines def format(self, record): message = {'message': record.getMessage(), 'asctime': self.formatTime(record, self.datefmt), 'name': record.name, 'msg': record.msg, 'args': record.args, 'levelname': record.levelname, 'levelno': record.levelno, 'pathname': record.pathname, 'filename': record.filename, 'module': record.module, 'lineno': record.lineno, 'funcname': record.funcName, 'created': record.created, 'msecs': record.msecs, 'relative_created': record.relativeCreated, 'thread': record.thread, 'thread_name': record.threadName, 'process_name': record.processName, 'process': record.process, 'traceback': None} if hasattr(record, 'extra'): message['extra'] = record.extra if record.exc_info: message['traceback'] = self.formatException(record.exc_info) return jsonutils.dumps(message) def _create_logging_excepthook(product_name): def logging_excepthook(exc_type, value, tb): extra = {} if CONF.verbose or CONF.debug: extra['exc_info'] = (exc_type, value, tb) getLogger(product_name).critical( "".join(traceback.format_exception_only(exc_type, value)), **extra) return logging_excepthook class LogConfigError(Exception): message = _('Error loading logging config %(log_config)s: %(err_msg)s') def __init__(self, log_config, err_msg): self.log_config = log_config self.err_msg = err_msg def __str__(self): return self.message % dict(log_config=self.log_config, err_msg=self.err_msg) def _load_log_config(log_config_append): try: logging.config.fileConfig(log_config_append, disable_existing_loggers=False) except moves.configparser.Error as exc: raise LogConfigError(log_config_append, str(exc)) def setup(product_name): """Setup logging.""" if CONF.log_config_append: _load_log_config(CONF.log_config_append) else: _setup_logging_from_conf() sys.excepthook = _create_logging_excepthook(product_name) def set_defaults(logging_context_format_string): cfg.set_defaults(log_opts, logging_context_format_string= logging_context_format_string) def _find_facility_from_conf(): facility_names = logging.handlers.SysLogHandler.facility_names facility = getattr(logging.handlers.SysLogHandler, CONF.syslog_log_facility, None) if facility is None and CONF.syslog_log_facility in facility_names: facility = facility_names.get(CONF.syslog_log_facility) if facility is None: valid_facilities = facility_names.keys() consts = ['LOG_AUTH', 'LOG_AUTHPRIV', 'LOG_CRON', 'LOG_DAEMON', 'LOG_FTP', 'LOG_KERN', 'LOG_LPR', 'LOG_MAIL', 'LOG_NEWS', 'LOG_AUTH', 'LOG_SYSLOG', 'LOG_USER', 'LOG_UUCP', 'LOG_LOCAL0', 'LOG_LOCAL1', 'LOG_LOCAL2', 'LOG_LOCAL3', 'LOG_LOCAL4', 'LOG_LOCAL5', 'LOG_LOCAL6', 'LOG_LOCAL7'] valid_facilities.extend(consts) raise TypeError(_('syslog facility must be one of: %s') % ', '.join("'%s'" % fac for fac in valid_facilities)) return facility def _setup_logging_from_conf(): log_root = getLogger(None).logger for handler in log_root.handlers: log_root.removeHandler(handler) if CONF.use_syslog: facility = _find_facility_from_conf() syslog = logging.handlers.SysLogHandler(address='/dev/log', facility=facility) log_root.addHandler(syslog) logpath = _get_log_file_path() if logpath: filelog = logging.handlers.WatchedFileHandler(logpath) log_root.addHandler(filelog) if CONF.use_stderr: streamlog = ColorHandler() log_root.addHandler(streamlog) elif not logpath: # pass sys.stdout as a positional argument # python2.6 calls the argument strm, in 2.7 it's stream streamlog = logging.StreamHandler(sys.stdout) log_root.addHandler(streamlog) if CONF.publish_errors: handler = importutils.import_object( "heat.openstack.common.log_handler.PublishErrorsHandler", logging.ERROR) log_root.addHandler(handler) datefmt = CONF.log_date_format for handler in log_root.handlers: # NOTE(alaski): CONF.log_format overrides everything currently. This # should be deprecated in favor of context aware formatting. if CONF.log_format: handler.setFormatter(logging.Formatter(fmt=CONF.log_format, datefmt=datefmt)) log_root.info('Deprecated: log_format is now deprecated and will ' 'be removed in the next release') else: handler.setFormatter(ContextFormatter(datefmt=datefmt)) if CONF.debug: log_root.setLevel(logging.DEBUG) elif CONF.verbose: log_root.setLevel(logging.INFO) else: log_root.setLevel(logging.WARNING) for pair in CONF.default_log_levels: mod, _sep, level_name = pair.partition('=') level = logging.getLevelName(level_name) logger = logging.getLogger(mod) logger.setLevel(level) _loggers = {} def getLogger(name='unknown', version='unknown'): if name not in _loggers: _loggers[name] = ContextAdapter(logging.getLogger(name), name, version) return _loggers[name] def getLazyLogger(name='unknown', version='unknown'): """Returns lazy logger. Creates a pass-through logger that does not create the real logger until it is really needed and delegates all calls to the real logger once it is created. """ return LazyAdapter(name, version) class WritableLogger(object): """A thin wrapper that responds to `write` and logs.""" def __init__(self, logger, level=logging.INFO): self.logger = logger self.level = level def write(self, msg): self.logger.log(self.level, msg.rstrip()) class ContextFormatter(logging.Formatter): """A context.RequestContext aware formatter configured through flags. The flags used to set format strings are: logging_context_format_string and logging_default_format_string. You can also specify logging_debug_format_suffix to append extra formatting if the log level is debug. For information about what variables are available for the formatter see: http://docs.python.org/library/logging.html#formatter """ def format(self, record): """Uses contextstring if request_id is set, otherwise default.""" # NOTE(sdague): default the fancier formatting params # to an empty string so we don't throw an exception if # they get used for key in ('instance', 'color'): if key not in record.__dict__: record.__dict__[key] = '' if record.__dict__.get('request_id', None): self._fmt = CONF.logging_context_format_string else: self._fmt = CONF.logging_default_format_string if (record.levelno == logging.DEBUG and CONF.logging_debug_format_suffix): self._fmt += " " + CONF.logging_debug_format_suffix # Cache this on the record, Logger will respect our formatted copy if record.exc_info: record.exc_text = self.formatException(record.exc_info, record) return logging.Formatter.format(self, record) def formatException(self, exc_info, record=None): """Format exception output with CONF.logging_exception_prefix.""" if not record: return logging.Formatter.formatException(self, exc_info) stringbuffer = moves.StringIO() traceback.print_exception(exc_info[0], exc_info[1], exc_info[2], None, stringbuffer) lines = stringbuffer.getvalue().split('\n') stringbuffer.close() if CONF.logging_exception_prefix.find('%(asctime)') != -1: record.asctime = self.formatTime(record, self.datefmt) formatted_lines = [] for line in lines: pl = CONF.logging_exception_prefix % record.__dict__ fl = '%s%s' % (pl, line) formatted_lines.append(fl) return '\n'.join(formatted_lines) class ColorHandler(logging.StreamHandler): LEVEL_COLORS = { logging.DEBUG: '\033[00;32m', # GREEN logging.INFO: '\033[00;36m', # CYAN logging.AUDIT: '\033[01;36m', # BOLD CYAN logging.WARN: '\033[01;33m', # BOLD YELLOW logging.ERROR: '\033[01;31m', # BOLD RED logging.CRITICAL: '\033[01;31m', # BOLD RED } def format(self, record): record.color = self.LEVEL_COLORS[record.levelno] return logging.StreamHandler.format(self, record) class DeprecatedConfig(Exception): message = _("Fatal call to deprecated config: %(msg)s") def __init__(self, msg): super(Exception, self).__init__(self.message % dict(msg=msg)) heat-2014.1.5/heat/openstack/common/__init__.py0000664000567000056700000000120412540642614022337 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. import six six.add_move(six.MovedModule('mox', 'mox', 'mox3.mox')) heat-2014.1.5/heat/openstack/common/local.py0000664000567000056700000000321512540642614021676 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. """Local storage of variables using weak references""" import threading import weakref class WeakLocal(threading.local): def __getattribute__(self, attr): rval = super(WeakLocal, self).__getattribute__(attr) if rval: # NOTE(mikal): this bit is confusing. What is stored is a weak # reference, not the value itself. We therefore need to lookup # the weak reference and return the inner value here. rval = rval() return rval def __setattr__(self, attr, value): value = weakref.ref(value) return super(WeakLocal, self).__setattr__(attr, value) # NOTE(mikal): the name "store" should be deprecated in the future store = WeakLocal() # A "weak" store uses weak references and allows an object to fall out of scope # when it falls out of scope in the code that uses the thread local storage. A # "strong" store will hold a reference to the object so that it never falls out # of scope. weak_store = WeakLocal() strong_store = threading.local() heat-2014.1.5/heat/openstack/common/fixture/0000775000567000056700000000000012540643116021715 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/fixture/lockutils.py0000664000567000056700000000353712540642614024312 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. import fixtures from heat.openstack.common import lockutils class LockFixture(fixtures.Fixture): """External locking fixture. This fixture is basically an alternative to the synchronized decorator with the external flag so that tearDowns and addCleanups will be included in the lock context for locking between tests. The fixture is recommended to be the first line in a test method, like so:: def test_method(self): self.useFixture(LockFixture) ... or the first line in setUp if all the test methods in the class are required to be serialized. Something like:: class TestCase(testtools.testcase): def setUp(self): self.useFixture(LockFixture) super(TestCase, self).setUp() ... This is because addCleanups are put on a LIFO queue that gets run after the test method exits. (either by completing or raising an exception) """ def __init__(self, name, lock_file_prefix=None): self.mgr = lockutils.lock(name, lock_file_prefix, True) def setUp(self): super(LockFixture, self).setUp() self.addCleanup(self.mgr.__exit__, None, None, None) self.mgr.__enter__() heat-2014.1.5/heat/openstack/common/fixture/config.py0000664000567000056700000000271112540642614023537 0ustar jenkinsjenkins00000000000000# # Copyright 2013 Mirantis, Inc. # Copyright 2013 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. import fixtures from oslo.config import cfg import six class Config(fixtures.Fixture): """Override some configuration values. The keyword arguments are the names of configuration options to override and their values. If a group argument is supplied, the overrides are applied to the specified configuration option group. All overrides are automatically cleared at the end of the current test by the reset() method, which is registered by addCleanup(). """ def __init__(self, conf=cfg.CONF): self.conf = conf def setUp(self): super(Config, self).setUp() self.addCleanup(self.conf.reset) def config(self, **kw): group = kw.pop('group', None) for k, v in six.iteritems(kw): self.conf.set_override(k, v, group) heat-2014.1.5/heat/openstack/common/fixture/__init__.py0000664000567000056700000000000012540642614024016 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/fixture/moxstubout.py0000664000567000056700000000230712540642614024524 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2013 Hewlett-Packard Development Company, L.P. # 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. import fixtures import mox class MoxStubout(fixtures.Fixture): """Deal with code around mox and stubout as a fixture.""" def setUp(self): super(MoxStubout, self).setUp() # emulate some of the mox stuff, we can't use the metaclass # because it screws with our generators self.mox = mox.Mox() self.stubs = self.mox.stubs self.addCleanup(self.mox.UnsetStubs) self.addCleanup(self.mox.VerifyAll) heat-2014.1.5/heat/openstack/common/fixture/mockpatch.py0000664000567000056700000000276612540642614024255 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2013 Hewlett-Packard Development Company, L.P. # 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. import fixtures import mock class PatchObject(fixtures.Fixture): """Deal with code around mock.""" def __init__(self, obj, attr, **kwargs): self.obj = obj self.attr = attr self.kwargs = kwargs def setUp(self): super(PatchObject, self).setUp() _p = mock.patch.object(self.obj, self.attr, **self.kwargs) self.mock = _p.start() self.addCleanup(_p.stop) class Patch(fixtures.Fixture): """Deal with code around mock.patch.""" def __init__(self, obj, **kwargs): self.obj = obj self.kwargs = kwargs def setUp(self): super(Patch, self).setUp() _p = mock.patch(self.obj, **self.kwargs) self.mock = _p.start() self.addCleanup(_p.stop) heat-2014.1.5/heat/openstack/common/threadgroup.py0000664000567000056700000001127612540642614023136 0ustar jenkinsjenkins00000000000000# Copyright 2012 Red Hat, Inc. # # 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. import threading import eventlet from eventlet import greenpool from heat.openstack.common import log as logging from heat.openstack.common import loopingcall LOG = logging.getLogger(__name__) def _thread_done(gt, *args, **kwargs): """Callback function to be passed to GreenThread.link() when we spawn() Calls the :class:`ThreadGroup` to notify if. """ kwargs['group'].thread_done(kwargs['thread']) class Thread(object): """Wrapper around a greenthread, that holds a reference to the :class:`ThreadGroup`. The Thread will notify the :class:`ThreadGroup` when it has done so it can be removed from the threads list. """ def __init__(self, thread, group): self.thread = thread self.thread.link(_thread_done, group=group, thread=self) def stop(self): self.thread.kill() def wait(self): return self.thread.wait() def link(self, func, *args, **kwargs): self.thread.link(func, *args, **kwargs) class ThreadGroup(object): """The point of the ThreadGroup class is to: * keep track of timers and greenthreads (making it easier to stop them when need be). * provide an easy API to add timers. """ def __init__(self, thread_pool_size=10): self.pool = greenpool.GreenPool(thread_pool_size) self.threads = [] self.timers = [] def add_dynamic_timer(self, callback, initial_delay=None, periodic_interval_max=None, *args, **kwargs): timer = loopingcall.DynamicLoopingCall(callback, *args, **kwargs) timer.start(initial_delay=initial_delay, periodic_interval_max=periodic_interval_max) self.timers.append(timer) def add_timer(self, interval, callback, initial_delay=None, *args, **kwargs): pulse = loopingcall.FixedIntervalLoopingCall(callback, *args, **kwargs) pulse.start(interval=interval, initial_delay=initial_delay) self.timers.append(pulse) def add_thread(self, callback, *args, **kwargs): gt = self.pool.spawn(callback, *args, **kwargs) th = Thread(gt, self) self.threads.append(th) return th def thread_done(self, thread): self.threads.remove(thread) def _stop_threads(self): current = threading.current_thread() # Iterate over a copy of self.threads so thread_done doesn't # modify the list while we're iterating for x in self.threads[:]: if x is current: # don't kill the current thread. continue try: x.stop() except Exception as ex: LOG.exception(ex) def stop_timers(self): for x in self.timers: try: x.stop() except Exception as ex: LOG.exception(ex) self.timers = [] def stop(self, graceful=False): """stop function has the option of graceful=True/False. * In case of graceful=True, wait for all threads to be finished. Never kill threads. * In case of graceful=False, kill threads immediately. """ self.stop_timers() if graceful: # In case of graceful=True, wait for all threads to be # finished, never kill threads self.wait() else: # In case of graceful=False(Default), kill threads # immediately self._stop_threads() def wait(self): for x in self.timers: try: x.wait() except eventlet.greenlet.GreenletExit: pass except Exception as ex: LOG.exception(ex) current = threading.current_thread() # Iterate over a copy of self.threads so thread_done doesn't # modify the list while we're iterating for x in self.threads[:]: if x is current: continue try: x.wait() except eventlet.greenlet.GreenletExit: pass except Exception as ex: LOG.exception(ex) heat-2014.1.5/heat/openstack/common/service.py0000664000567000056700000003503512540642614022251 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2011 Justin Santa Barbara # 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. """Generic Node base class for all workers that run on hosts.""" import errno import logging as std_logging import os import random import signal import sys import threading import time try: # Importing just the symbol here because the io module does not # exist in Python 2.6. from io import UnsupportedOperation # noqa except ImportError: # Python 2.6 UnsupportedOperation = None import eventlet from oslo.config import cfg from heat.openstack.common import eventlet_backdoor from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import log as logging from heat.openstack.common import threadgroup rpc = importutils.try_import('heat.openstack.common.rpc') CONF = cfg.CONF LOG = logging.getLogger(__name__) def _sighup_supported(): return hasattr(signal, 'SIGHUP') def _is_daemon(): # The process group for a foreground process will match the # process group of the controlling terminal. If those values do # not match, or ioctl() fails on the stdout file handle, we assume # the process is running in the background as a daemon. # http://www.gnu.org/software/bash/manual/bashref.html#Job-Control-Basics try: is_daemon = os.getpgrp() != os.tcgetpgrp(sys.stdout.fileno()) except OSError as err: if err.errno == errno.ENOTTY: # Assume we are a daemon because there is no terminal. is_daemon = True else: raise except UnsupportedOperation: # Could not get the fileno for stdout, so we must be a daemon. is_daemon = True return is_daemon def _is_sighup_and_daemon(signo): if not (_sighup_supported() and signo == signal.SIGHUP): # Avoid checking if we are a daemon, because the signal isn't # SIGHUP. return False return _is_daemon() def _signo_to_signame(signo): signals = {signal.SIGTERM: 'SIGTERM', signal.SIGINT: 'SIGINT'} if _sighup_supported(): signals[signal.SIGHUP] = 'SIGHUP' return signals[signo] def _set_signals_handler(handler): signal.signal(signal.SIGTERM, handler) signal.signal(signal.SIGINT, handler) if _sighup_supported(): signal.signal(signal.SIGHUP, handler) class Launcher(object): """Launch one or more services and wait for them to complete.""" def __init__(self): """Initialize the service launcher. :returns: None """ self.services = Services() self.backdoor_port = eventlet_backdoor.initialize_if_enabled() def launch_service(self, service): """Load and start the given service. :param service: The service you would like to start. :returns: None """ service.backdoor_port = self.backdoor_port self.services.add(service) def stop(self): """Stop all services which are currently running. :returns: None """ self.services.stop() def wait(self): """Waits until all services have been stopped, and then returns. :returns: None """ self.services.wait() def restart(self): """Reload config files and restart service. :returns: None """ cfg.CONF.reload_config_files() self.services.restart() class SignalExit(SystemExit): def __init__(self, signo, exccode=1): super(SignalExit, self).__init__(exccode) self.signo = signo class ServiceLauncher(Launcher): def _handle_signal(self, signo, frame): # Allow the process to be killed again and die from natural causes _set_signals_handler(signal.SIG_DFL) raise SignalExit(signo) def handle_signal(self): _set_signals_handler(self._handle_signal) def _wait_for_exit_or_signal(self, ready_callback=None): status = None signo = 0 LOG.debug(_('Full set of CONF:')) CONF.log_opt_values(LOG, std_logging.DEBUG) try: if ready_callback: ready_callback() super(ServiceLauncher, self).wait() except SignalExit as exc: signame = _signo_to_signame(exc.signo) LOG.info(_('Caught %s, exiting'), signame) status = exc.code signo = exc.signo except SystemExit as exc: status = exc.code finally: self.stop() if rpc: try: rpc.cleanup() except Exception: # We're shutting down, so it doesn't matter at this point. LOG.exception(_('Exception during rpc cleanup.')) return status, signo def wait(self, ready_callback=None): while True: self.handle_signal() status, signo = self._wait_for_exit_or_signal(ready_callback) if not _is_sighup_and_daemon(signo): return status self.restart() class ServiceWrapper(object): def __init__(self, service, workers): self.service = service self.workers = workers self.children = set() self.forktimes = [] class ProcessLauncher(object): def __init__(self, wait_interval=0.01): """Constructor. :param wait_interval: The interval to sleep for between checks of child process exit. """ self.children = {} self.sigcaught = None self.running = True self.wait_interval = wait_interval rfd, self.writepipe = os.pipe() self.readpipe = eventlet.greenio.GreenPipe(rfd, 'r') self.handle_signal() def handle_signal(self): _set_signals_handler(self._handle_signal) def _handle_signal(self, signo, frame): self.sigcaught = signo self.running = False # Allow the process to be killed again and die from natural causes _set_signals_handler(signal.SIG_DFL) def _pipe_watcher(self): # This will block until the write end is closed when the parent # dies unexpectedly self.readpipe.read() LOG.info(_('Parent process has died unexpectedly, exiting')) sys.exit(1) def _child_process_handle_signal(self): # Setup child signal handlers differently def _sigterm(*args): signal.signal(signal.SIGTERM, signal.SIG_DFL) raise SignalExit(signal.SIGTERM) def _sighup(*args): signal.signal(signal.SIGHUP, signal.SIG_DFL) raise SignalExit(signal.SIGHUP) signal.signal(signal.SIGTERM, _sigterm) if _sighup_supported(): signal.signal(signal.SIGHUP, _sighup) # Block SIGINT and let the parent send us a SIGTERM signal.signal(signal.SIGINT, signal.SIG_IGN) def _child_wait_for_exit_or_signal(self, launcher): status = 0 signo = 0 # NOTE(johannes): All exceptions are caught to ensure this # doesn't fallback into the loop spawning children. It would # be bad for a child to spawn more children. try: launcher.wait() except SignalExit as exc: signame = _signo_to_signame(exc.signo) LOG.info(_('Caught %s, exiting'), signame) status = exc.code signo = exc.signo except SystemExit as exc: status = exc.code except BaseException: LOG.exception(_('Unhandled exception')) status = 2 finally: launcher.stop() return status, signo def _child_process(self, service): self._child_process_handle_signal() # Reopen the eventlet hub to make sure we don't share an epoll # fd with parent and/or siblings, which would be bad eventlet.hubs.use_hub() # Close write to ensure only parent has it open os.close(self.writepipe) # Create greenthread to watch for parent to close pipe eventlet.spawn_n(self._pipe_watcher) # Reseed random number generator random.seed() launcher = Launcher() launcher.launch_service(service) return launcher def _start_child(self, wrap): if len(wrap.forktimes) > wrap.workers: # Limit ourselves to one process a second (over the period of # number of workers * 1 second). This will allow workers to # start up quickly but ensure we don't fork off children that # die instantly too quickly. if time.time() - wrap.forktimes[0] < wrap.workers: LOG.info(_('Forking too fast, sleeping')) time.sleep(1) wrap.forktimes.pop(0) wrap.forktimes.append(time.time()) pid = os.fork() if pid == 0: launcher = self._child_process(wrap.service) while True: self._child_process_handle_signal() status, signo = self._child_wait_for_exit_or_signal(launcher) if not _is_sighup_and_daemon(signo): break launcher.restart() os._exit(status) LOG.info(_('Started child %d'), pid) wrap.children.add(pid) self.children[pid] = wrap return pid def launch_service(self, service, workers=1): wrap = ServiceWrapper(service, workers) LOG.info(_('Starting %d workers'), wrap.workers) while self.running and len(wrap.children) < wrap.workers: self._start_child(wrap) def _wait_child(self): try: # Don't block if no child processes have exited pid, status = os.waitpid(0, os.WNOHANG) if not pid: return None except OSError as exc: if exc.errno not in (errno.EINTR, errno.ECHILD): raise return None if os.WIFSIGNALED(status): sig = os.WTERMSIG(status) LOG.info(_('Child %(pid)d killed by signal %(sig)d'), dict(pid=pid, sig=sig)) else: code = os.WEXITSTATUS(status) LOG.info(_('Child %(pid)s exited with status %(code)d'), dict(pid=pid, code=code)) if pid not in self.children: LOG.warning(_('pid %d not in child list'), pid) return None wrap = self.children.pop(pid) wrap.children.remove(pid) return wrap def _respawn_children(self): while self.running: wrap = self._wait_child() if not wrap: # Yield to other threads if no children have exited # Sleep for a short time to avoid excessive CPU usage # (see bug #1095346) eventlet.greenthread.sleep(self.wait_interval) continue while self.running and len(wrap.children) < wrap.workers: self._start_child(wrap) def wait(self): """Loop waiting on children to die and respawning as necessary.""" LOG.debug(_('Full set of CONF:')) CONF.log_opt_values(LOG, std_logging.DEBUG) while True: self.handle_signal() self._respawn_children() if self.sigcaught: signame = _signo_to_signame(self.sigcaught) LOG.info(_('Caught %s, stopping children'), signame) if not _is_sighup_and_daemon(self.sigcaught): break for pid in self.children: os.kill(pid, signal.SIGHUP) self.running = True self.sigcaught = None for pid in self.children: try: os.kill(pid, signal.SIGTERM) except OSError as exc: if exc.errno != errno.ESRCH: raise # Wait for children to die if self.children: LOG.info(_('Waiting on %d children to exit'), len(self.children)) while self.children: self._wait_child() class Service(object): """Service object for binaries running on hosts.""" def __init__(self, threads=1000): self.tg = threadgroup.ThreadGroup(threads) # signal that the service is done shutting itself down: self._done = threading.Event() def reset(self): self._done = threading.Event() def start(self): pass def stop(self): self.tg.stop() self.tg.wait() # Signal that service cleanup is done: self._done.set() def wait(self): self._done.wait() class Services(object): def __init__(self): self.services = [] self.tg = threadgroup.ThreadGroup() self.done = threading.Event() def add(self, service): self.services.append(service) self.tg.add_thread(self.run_service, service, self.done) def stop(self): # wait for graceful shutdown of services: for service in self.services: service.stop() service.wait() # Each service has performed cleanup, now signal that the run_service # wrapper threads can now die: self.done.set() # reap threads: self.tg.stop() def wait(self): self.tg.wait() def restart(self): self.stop() self.done = threading.Event() for restart_service in self.services: restart_service.reset() self.tg.add_thread(self.run_service, restart_service, self.done) @staticmethod def run_service(service, done): """Service start wrapper. :param service: service to run :param done: event to wait on until a shutdown is triggered :returns: None """ service.start() done.wait() def launch(service, workers=None): if workers: launcher = ProcessLauncher() launcher.launch_service(service, workers=workers) else: launcher = ServiceLauncher() launcher.launch_service(service) return launcher heat-2014.1.5/heat/openstack/common/uuidutils.py0000664000567000056700000000204512540642614022633 0ustar jenkinsjenkins00000000000000# Copyright (c) 2012 Intel Corporation. # 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. """ UUID related utilities and helper functions. """ import uuid def generate_uuid(): return str(uuid.uuid4()) def is_uuid_like(val): """Returns validation of a value as a UUID. For our purposes, a UUID is a canonical form string: aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa """ try: return str(uuid.UUID(val)) == val except (TypeError, ValueError, AttributeError): return False heat-2014.1.5/heat/openstack/common/versionutils.py0000664000567000056700000001153412540642614023355 0ustar jenkinsjenkins00000000000000# Copyright (c) 2013 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. """ Helpers for comparing version strings. """ import functools import pkg_resources from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging LOG = logging.getLogger(__name__) class deprecated(object): """A decorator to mark callables as deprecated. This decorator logs a deprecation message when the callable it decorates is used. The message will include the release where the callable was deprecated, the release where it may be removed and possibly an optional replacement. Examples: 1. Specifying the required deprecated release >>> @deprecated(as_of=deprecated.ICEHOUSE) ... def a(): pass 2. Specifying a replacement: >>> @deprecated(as_of=deprecated.ICEHOUSE, in_favor_of='f()') ... def b(): pass 3. Specifying the release where the functionality may be removed: >>> @deprecated(as_of=deprecated.ICEHOUSE, remove_in=+1) ... def c(): pass """ FOLSOM = 'F' GRIZZLY = 'G' HAVANA = 'H' ICEHOUSE = 'I' _RELEASES = { 'F': 'Folsom', 'G': 'Grizzly', 'H': 'Havana', 'I': 'Icehouse', } _deprecated_msg_with_alternative = _( '%(what)s is deprecated as of %(as_of)s in favor of ' '%(in_favor_of)s and may be removed in %(remove_in)s.') _deprecated_msg_no_alternative = _( '%(what)s is deprecated as of %(as_of)s and may be ' 'removed in %(remove_in)s. It will not be superseded.') def __init__(self, as_of, in_favor_of=None, remove_in=2, what=None): """Initialize decorator :param as_of: the release deprecating the callable. Constants are define in this class for convenience. :param in_favor_of: the replacement for the callable (optional) :param remove_in: an integer specifying how many releases to wait before removing (default: 2) :param what: name of the thing being deprecated (default: the callable's name) """ self.as_of = as_of self.in_favor_of = in_favor_of self.remove_in = remove_in self.what = what def __call__(self, func): if not self.what: self.what = func.__name__ + '()' @functools.wraps(func) def wrapped(*args, **kwargs): msg, details = self._build_message() LOG.deprecated(msg, details) return func(*args, **kwargs) return wrapped def _get_safe_to_remove_release(self, release): # TODO(dstanek): this method will have to be reimplemented once # when we get to the X release because once we get to the Y # release, what is Y+2? new_release = chr(ord(release) + self.remove_in) if new_release in self._RELEASES: return self._RELEASES[new_release] else: return new_release def _build_message(self): details = dict(what=self.what, as_of=self._RELEASES[self.as_of], remove_in=self._get_safe_to_remove_release(self.as_of)) if self.in_favor_of: details['in_favor_of'] = self.in_favor_of msg = self._deprecated_msg_with_alternative else: msg = self._deprecated_msg_no_alternative return msg, details def is_compatible(requested_version, current_version, same_major=True): """Determine whether `requested_version` is satisfied by `current_version`; in other words, `current_version` is >= `requested_version`. :param requested_version: version to check for compatibility :param current_version: version to check against :param same_major: if True, the major version must be identical between `requested_version` and `current_version`. This is used when a major-version difference indicates incompatibility between the two versions. Since this is the common-case in practice, the default is True. :returns: True if compatible, False if not """ requested_parts = pkg_resources.parse_version(requested_version) current_parts = pkg_resources.parse_version(current_version) if same_major and (requested_parts[0] != current_parts[0]): return False return current_parts >= requested_parts heat-2014.1.5/heat/openstack/common/processutils.py0000664000567000056700000002227312540642614023350 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. """ System-level utilities and helper functions. """ import logging as stdlib_logging import os import random import shlex import signal from eventlet.green import subprocess from eventlet import greenthread from heat.openstack.common.gettextutils import _ # noqa from heat.openstack.common import log as logging LOG = logging.getLogger(__name__) class InvalidArgumentError(Exception): def __init__(self, message=None): super(InvalidArgumentError, self).__init__(message) class UnknownArgumentError(Exception): def __init__(self, message=None): super(UnknownArgumentError, self).__init__(message) class ProcessExecutionError(Exception): def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None, description=None): self.exit_code = exit_code self.stderr = stderr self.stdout = stdout self.cmd = cmd self.description = description if description is None: description = "Unexpected error while running command." if exit_code is None: exit_code = '-' message = ("%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r" % (description, cmd, exit_code, stdout, stderr)) super(ProcessExecutionError, self).__init__(message) class NoRootWrapSpecified(Exception): def __init__(self, message=None): super(NoRootWrapSpecified, self).__init__(message) def _subprocess_setup(): # Python installs a SIGPIPE handler by default. This is usually not what # non-Python subprocesses expect. signal.signal(signal.SIGPIPE, signal.SIG_DFL) def execute(*cmd, **kwargs): """Helper method to shell out and execute a command through subprocess. Allows optional retry. :param cmd: Passed to subprocess.Popen. :type cmd: string :param process_input: Send to opened process. :type process_input: string :param check_exit_code: Single bool, int, or list of allowed exit codes. Defaults to [0]. Raise :class:`ProcessExecutionError` unless program exits with one of these code. :type check_exit_code: boolean, int, or [int] :param delay_on_retry: True | False. Defaults to True. If set to True, wait a short amount of time before retrying. :type delay_on_retry: boolean :param attempts: How many times to retry cmd. :type attempts: int :param run_as_root: True | False. Defaults to False. If set to True, the command is prefixed by the command specified in the root_helper kwarg. :type run_as_root: boolean :param root_helper: command to prefix to commands called with run_as_root=True :type root_helper: string :param shell: whether or not there should be a shell used to execute this command. Defaults to false. :type shell: boolean :param loglevel: log level for execute commands. :type loglevel: int. (Should be stdlib_logging.DEBUG or stdlib_logging.INFO) :returns: (stdout, stderr) from process execution :raises: :class:`UnknownArgumentError` on receiving unknown arguments :raises: :class:`ProcessExecutionError` """ process_input = kwargs.pop('process_input', None) check_exit_code = kwargs.pop('check_exit_code', [0]) ignore_exit_code = False delay_on_retry = kwargs.pop('delay_on_retry', True) attempts = kwargs.pop('attempts', 1) run_as_root = kwargs.pop('run_as_root', False) root_helper = kwargs.pop('root_helper', '') shell = kwargs.pop('shell', False) loglevel = kwargs.pop('loglevel', stdlib_logging.DEBUG) if isinstance(check_exit_code, bool): ignore_exit_code = not check_exit_code check_exit_code = [0] elif isinstance(check_exit_code, int): check_exit_code = [check_exit_code] if kwargs: raise UnknownArgumentError(_('Got unknown keyword args ' 'to utils.execute: %r') % kwargs) if run_as_root and hasattr(os, 'geteuid') and os.geteuid() != 0: if not root_helper: raise NoRootWrapSpecified( message=('Command requested root, but did not specify a root ' 'helper.')) cmd = shlex.split(root_helper) + list(cmd) cmd = map(str, cmd) while attempts > 0: attempts -= 1 try: LOG.log(loglevel, _('Running cmd (subprocess): %s'), ' '.join(cmd)) _PIPE = subprocess.PIPE # pylint: disable=E1101 if os.name == 'nt': preexec_fn = None close_fds = False else: preexec_fn = _subprocess_setup close_fds = True obj = subprocess.Popen(cmd, stdin=_PIPE, stdout=_PIPE, stderr=_PIPE, close_fds=close_fds, preexec_fn=preexec_fn, shell=shell) result = None if process_input is not None: result = obj.communicate(process_input) else: result = obj.communicate() obj.stdin.close() # pylint: disable=E1101 _returncode = obj.returncode # pylint: disable=E1101 LOG.log(loglevel, _('Result was %s') % _returncode) if not ignore_exit_code and _returncode not in check_exit_code: (stdout, stderr) = result raise ProcessExecutionError(exit_code=_returncode, stdout=stdout, stderr=stderr, cmd=' '.join(cmd)) return result except ProcessExecutionError: if not attempts: raise else: LOG.log(loglevel, _('%r failed. Retrying.'), cmd) if delay_on_retry: greenthread.sleep(random.randint(20, 200) / 100.0) finally: # NOTE(termie): this appears to be necessary to let the subprocess # call clean something up in between calls, without # it two execute calls in a row hangs the second one greenthread.sleep(0) def trycmd(*args, **kwargs): """A wrapper around execute() to more easily handle warnings and errors. Returns an (out, err) tuple of strings containing the output of the command's stdout and stderr. If 'err' is not empty then the command can be considered to have failed. :discard_warnings True | False. Defaults to False. If set to True, then for succeeding commands, stderr is cleared """ discard_warnings = kwargs.pop('discard_warnings', False) try: out, err = execute(*args, **kwargs) failed = False except ProcessExecutionError as exn: out, err = '', str(exn) failed = True if not failed and discard_warnings and err: # Handle commands that output to stderr but otherwise succeed err = '' return out, err def ssh_execute(ssh, cmd, process_input=None, addl_env=None, check_exit_code=True): LOG.debug(_('Running cmd (SSH): %s'), cmd) if addl_env: raise InvalidArgumentError(_('Environment not supported over SSH')) if process_input: # This is (probably) fixable if we need it... raise InvalidArgumentError(_('process_input not supported over SSH')) stdin_stream, stdout_stream, stderr_stream = ssh.exec_command(cmd) channel = stdout_stream.channel # NOTE(justinsb): This seems suspicious... # ...other SSH clients have buffering issues with this approach stdout = stdout_stream.read() stderr = stderr_stream.read() stdin_stream.close() exit_status = channel.recv_exit_status() # exit_status == -1 if no exit code was returned if exit_status != -1: LOG.debug(_('Result was %s') % exit_status) if check_exit_code and exit_status != 0: raise ProcessExecutionError(exit_code=exit_status, stdout=stdout, stderr=stderr, cmd=cmd) return (stdout, stderr) heat-2014.1.5/heat/openstack/common/importutils.py0000664000567000056700000000421512540642614023200 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. """ Import related utilities and helper functions. """ import sys import traceback def import_class(import_str): """Returns a class from a string including module and class.""" mod_str, _sep, class_str = import_str.rpartition('.') try: __import__(mod_str) return getattr(sys.modules[mod_str], class_str) except (ValueError, AttributeError): raise ImportError('Class %s cannot be found (%s)' % (class_str, traceback.format_exception(*sys.exc_info()))) def import_object(import_str, *args, **kwargs): """Import a class and return an instance of it.""" return import_class(import_str)(*args, **kwargs) def import_object_ns(name_space, import_str, *args, **kwargs): """Tries to import object from default namespace. Imports a class and return an instance of it, first by trying to find the class in a default namespace, then failing back to a full path if not found in the default namespace. """ import_value = "%s.%s" % (name_space, import_str) try: return import_class(import_value)(*args, **kwargs) except ImportError: return import_class(import_str)(*args, **kwargs) def import_module(import_str): """Import a module.""" __import__(import_str) return sys.modules[import_str] def try_import(import_str, default=None): """Try to import a module and if it fails return default.""" try: return import_module(import_str) except ImportError: return default heat-2014.1.5/heat/openstack/common/config/0000775000567000056700000000000012540643116021474 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/config/generator.py0000664000567000056700000002124312540642614024040 0ustar jenkinsjenkins00000000000000# Copyright 2012 SINA Corporation # 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. # """Extracts OpenStack config option info from module(s).""" from __future__ import print_function import imp import os import re import socket import sys import textwrap from oslo.config import cfg import six from heat.openstack.common import gettextutils from heat.openstack.common import importutils gettextutils.install('heat') STROPT = "StrOpt" BOOLOPT = "BoolOpt" INTOPT = "IntOpt" FLOATOPT = "FloatOpt" LISTOPT = "ListOpt" MULTISTROPT = "MultiStrOpt" OPT_TYPES = { STROPT: 'string value', BOOLOPT: 'boolean value', INTOPT: 'integer value', FLOATOPT: 'floating point value', LISTOPT: 'list value', MULTISTROPT: 'multi valued', } OPTION_REGEX = re.compile(r"(%s)" % "|".join([STROPT, BOOLOPT, INTOPT, FLOATOPT, LISTOPT, MULTISTROPT])) PY_EXT = ".py" BASEDIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../../")) WORDWRAP_WIDTH = 60 def generate(srcfiles): mods_by_pkg = dict() for filepath in srcfiles: pkg_name = filepath.split(os.sep)[1] mod_str = '.'.join(['.'.join(filepath.split(os.sep)[:-1]), os.path.basename(filepath).split('.')[0]]) mods_by_pkg.setdefault(pkg_name, list()).append(mod_str) # NOTE(lzyeval): place top level modules before packages pkg_names = filter(lambda x: x.endswith(PY_EXT), mods_by_pkg.keys()) pkg_names.sort() ext_names = filter(lambda x: x not in pkg_names, mods_by_pkg.keys()) ext_names.sort() pkg_names.extend(ext_names) # opts_by_group is a mapping of group name to an options list # The options list is a list of (module, options) tuples opts_by_group = {'DEFAULT': []} extra_modules = os.getenv("HEAT_CONFIG_GENERATOR_EXTRA_MODULES", "") if extra_modules: for module_name in extra_modules.split(','): module_name = module_name.strip() module = _import_module(module_name) if module: for group, opts in _list_opts(module): opts_by_group.setdefault(group, []).append((module_name, opts)) for pkg_name in pkg_names: mods = mods_by_pkg.get(pkg_name) mods.sort() for mod_str in mods: if mod_str.endswith('.__init__'): mod_str = mod_str[:mod_str.rfind(".")] mod_obj = _import_module(mod_str) if not mod_obj: raise RuntimeError("Unable to import module %s" % mod_str) for group, opts in _list_opts(mod_obj): opts_by_group.setdefault(group, []).append((mod_str, opts)) print_group_opts('DEFAULT', opts_by_group.pop('DEFAULT', [])) for group in sorted(opts_by_group.keys()): print_group_opts(group, opts_by_group[group]) def _import_module(mod_str): try: if mod_str.startswith('bin.'): imp.load_source(mod_str[4:], os.path.join('bin', mod_str[4:])) return sys.modules[mod_str[4:]] else: return importutils.import_module(mod_str) except Exception as e: sys.stderr.write("Error importing module %s: %s\n" % (mod_str, str(e))) return None def _is_in_group(opt, group): "Check if opt is in group." for key, value in group._opts.items(): if value['opt'] == opt: return True return False def _guess_groups(opt, mod_obj): # is it in the DEFAULT group? if _is_in_group(opt, cfg.CONF): return 'DEFAULT' # what other groups is it in? for key, value in cfg.CONF.items(): if isinstance(value, cfg.CONF.GroupAttr): if _is_in_group(opt, value._group): return value._group.name raise RuntimeError( "Unable to find group for option %s, " "maybe it's defined twice in the same group?" % opt.name ) def _list_opts(obj): def is_opt(o): return (isinstance(o, cfg.Opt) and not isinstance(o, cfg.SubCommandOpt)) opts = list() for attr_str in dir(obj): attr_obj = getattr(obj, attr_str) if is_opt(attr_obj): opts.append(attr_obj) elif (isinstance(attr_obj, list) and all(map(lambda x: is_opt(x), attr_obj))): opts.extend(attr_obj) ret = {} for opt in opts: ret.setdefault(_guess_groups(opt, obj), []).append(opt) return ret.items() def print_group_opts(group, opts_by_module): print("[%s]" % group) print('') for mod, opts in opts_by_module: print('#') print('# Options defined in %s' % mod) print('#') print('') for opt in opts: _print_opt(opt) print('') def _get_my_ip(): try: csock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) csock.connect(('8.8.8.8', 80)) (addr, port) = csock.getsockname() csock.close() return addr except socket.error: return None def _sanitize_default(name, value): """Set up a reasonably sensible default for pybasedir, my_ip and host.""" if value.startswith(sys.prefix): # NOTE(jd) Don't use os.path.join, because it is likely to think the # second part is an absolute pathname and therefore drop the first # part. value = os.path.normpath("/usr/" + value[len(sys.prefix):]) elif value.startswith(BASEDIR): return value.replace(BASEDIR, '/usr/lib/python/site-packages') elif BASEDIR in value: return value.replace(BASEDIR, '') elif value == _get_my_ip(): return '10.0.0.1' elif value == socket.gethostname() and 'host' in name: return 'heat' elif value.strip() != value: return '"%s"' % value return value def _print_opt(opt): opt_name, opt_default, opt_help = opt.dest, opt.default, opt.help if not opt_help: sys.stderr.write('WARNING: "%s" is missing help string.\n' % opt_name) opt_help = "" opt_type = None try: opt_type = OPTION_REGEX.search(str(type(opt))).group(0) except (ValueError, AttributeError) as err: sys.stderr.write("%s\n" % str(err)) sys.exit(1) opt_help += ' (' + OPT_TYPES[opt_type] + ')' print('#', "\n# ".join(textwrap.wrap(opt_help, WORDWRAP_WIDTH))) if opt.deprecated_opts: for deprecated_opt in opt.deprecated_opts: if deprecated_opt.name: deprecated_group = (deprecated_opt.group if deprecated_opt.group else "DEFAULT") print('# Deprecated group/name - [%s]/%s' % (deprecated_group, deprecated_opt.name)) try: if opt_default is None: print('#%s=' % opt_name) elif opt_type == STROPT: assert(isinstance(opt_default, six.string_types)) print('#%s=%s' % (opt_name, _sanitize_default(opt_name, opt_default))) elif opt_type == BOOLOPT: assert(isinstance(opt_default, bool)) print('#%s=%s' % (opt_name, str(opt_default).lower())) elif opt_type == INTOPT: assert(isinstance(opt_default, int) and not isinstance(opt_default, bool)) print('#%s=%s' % (opt_name, opt_default)) elif opt_type == FLOATOPT: assert(isinstance(opt_default, float)) print('#%s=%s' % (opt_name, opt_default)) elif opt_type == LISTOPT: assert(isinstance(opt_default, list)) print('#%s=%s' % (opt_name, ','.join(opt_default))) elif opt_type == MULTISTROPT: assert(isinstance(opt_default, list)) if not opt_default: opt_default = [''] for default in opt_default: print('#%s=%s' % (opt_name, default)) print('') except Exception: sys.stderr.write('Error in option "%s"\n' % opt_name) sys.exit(1) def main(): generate(sys.argv[1:]) if __name__ == '__main__': main() heat-2014.1.5/heat/openstack/common/config/__init__.py0000664000567000056700000000000012540642614023575 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/rpc/0000775000567000056700000000000012540643116021013 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/rpc/impl_zmq.py0000664000567000056700000006347712540642614023240 0ustar jenkinsjenkins00000000000000# Copyright 2011 Cloudscaling Group, Inc # # 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. import os import pprint import re import socket import sys import types import uuid import eventlet import greenlet from oslo.config import cfg import six from six import moves from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import jsonutils from heat.openstack.common.rpc import common as rpc_common zmq = importutils.try_import('eventlet.green.zmq') # for convenience, are not modified. pformat = pprint.pformat Timeout = eventlet.timeout.Timeout LOG = rpc_common.LOG RemoteError = rpc_common.RemoteError RPCException = rpc_common.RPCException zmq_opts = [ cfg.StrOpt('rpc_zmq_bind_address', default='*', help='ZeroMQ bind address. Should be a wildcard (*), ' 'an ethernet interface, or IP. ' 'The "host" option should point or resolve to this ' 'address.'), # The module.Class to use for matchmaking. cfg.StrOpt( 'rpc_zmq_matchmaker', default=('heat.openstack.common.rpc.' 'matchmaker.MatchMakerLocalhost'), help='MatchMaker driver', ), # The following port is unassigned by IANA as of 2012-05-21 cfg.IntOpt('rpc_zmq_port', default=9501, help='ZeroMQ receiver listening port'), cfg.IntOpt('rpc_zmq_contexts', default=1, help='Number of ZeroMQ contexts, defaults to 1'), cfg.IntOpt('rpc_zmq_topic_backlog', default=None, help='Maximum number of ingress messages to locally buffer ' 'per topic. Default is unlimited.'), cfg.StrOpt('rpc_zmq_ipc_dir', default='/var/run/openstack', help='Directory for holding IPC sockets'), cfg.StrOpt('rpc_zmq_host', default=socket.gethostname(), help='Name of this node. Must be a valid hostname, FQDN, or ' 'IP address. Must match "host" option, if running Nova.') ] CONF = cfg.CONF CONF.register_opts(zmq_opts) ZMQ_CTX = None # ZeroMQ Context, must be global. matchmaker = None # memorized matchmaker object def _serialize(data): """Serialization wrapper. We prefer using JSON, but it cannot encode all types. Error if a developer passes us bad data. """ try: return jsonutils.dumps(data, ensure_ascii=True) except TypeError: with excutils.save_and_reraise_exception(): LOG.error(_("JSON serialization failed.")) def _deserialize(data): """Deserialization wrapper.""" LOG.debug(_("Deserializing: %s"), data) return jsonutils.loads(data) class ZmqSocket(object): """A tiny wrapper around ZeroMQ. Simplifies the send/recv protocol and connection management. Can be used as a Context (supports the 'with' statement). """ def __init__(self, addr, zmq_type, bind=True, subscribe=None): self.sock = _get_ctxt().socket(zmq_type) self.addr = addr self.type = zmq_type self.subscriptions = [] # Support failures on sending/receiving on wrong socket type. self.can_recv = zmq_type in (zmq.PULL, zmq.SUB) self.can_send = zmq_type in (zmq.PUSH, zmq.PUB) self.can_sub = zmq_type in (zmq.SUB, ) # Support list, str, & None for subscribe arg (cast to list) do_sub = { list: subscribe, str: [subscribe], type(None): [] }[type(subscribe)] for f in do_sub: self.subscribe(f) str_data = {'addr': addr, 'type': self.socket_s(), 'subscribe': subscribe, 'bind': bind} LOG.debug(_("Connecting to %(addr)s with %(type)s"), str_data) LOG.debug(_("-> Subscribed to %(subscribe)s"), str_data) LOG.debug(_("-> bind: %(bind)s"), str_data) try: if bind: self.sock.bind(addr) else: self.sock.connect(addr) except Exception: raise RPCException(_("Could not open socket.")) def socket_s(self): """Get socket type as string.""" t_enum = ('PUSH', 'PULL', 'PUB', 'SUB', 'REP', 'REQ', 'ROUTER', 'DEALER') return dict(map(lambda t: (getattr(zmq, t), t), t_enum))[self.type] def subscribe(self, msg_filter): """Subscribe.""" if not self.can_sub: raise RPCException("Cannot subscribe on this socket.") LOG.debug(_("Subscribing to %s"), msg_filter) try: self.sock.setsockopt(zmq.SUBSCRIBE, msg_filter) except Exception: return self.subscriptions.append(msg_filter) def unsubscribe(self, msg_filter): """Unsubscribe.""" if msg_filter not in self.subscriptions: return self.sock.setsockopt(zmq.UNSUBSCRIBE, msg_filter) self.subscriptions.remove(msg_filter) def close(self): if self.sock is None or self.sock.closed: return # We must unsubscribe, or we'll leak descriptors. if self.subscriptions: for f in self.subscriptions: try: self.sock.setsockopt(zmq.UNSUBSCRIBE, f) except Exception: pass self.subscriptions = [] try: # Default is to linger self.sock.close() except Exception: # While this is a bad thing to happen, # it would be much worse if some of the code calling this # were to fail. For now, lets log, and later evaluate # if we can safely raise here. LOG.error(_("ZeroMQ socket could not be closed.")) self.sock = None def recv(self, **kwargs): if not self.can_recv: raise RPCException(_("You cannot recv on this socket.")) return self.sock.recv_multipart(**kwargs) def send(self, data, **kwargs): if not self.can_send: raise RPCException(_("You cannot send on this socket.")) self.sock.send_multipart(data, **kwargs) class ZmqClient(object): """Client for ZMQ sockets.""" def __init__(self, addr): self.outq = ZmqSocket(addr, zmq.PUSH, bind=False) def cast(self, msg_id, topic, data, envelope): msg_id = msg_id or 0 if not envelope: self.outq.send(map(bytes, (msg_id, topic, 'cast', _serialize(data)))) return rpc_envelope = rpc_common.serialize_msg(data[1], envelope) zmq_msg = moves.reduce(lambda x, y: x + y, rpc_envelope.items()) self.outq.send(map(bytes, (msg_id, topic, 'impl_zmq_v2', data[0]) + zmq_msg)) def close(self): self.outq.close() class RpcContext(rpc_common.CommonRpcContext): """Context that supports replying to a rpc.call.""" def __init__(self, **kwargs): self.replies = [] super(RpcContext, self).__init__(**kwargs) def deepcopy(self): values = self.to_dict() values['replies'] = self.replies return self.__class__(**values) def reply(self, reply=None, failure=None, ending=False): if ending: return self.replies.append(reply) @classmethod def marshal(self, ctx): ctx_data = ctx.to_dict() return _serialize(ctx_data) @classmethod def unmarshal(self, data): return RpcContext.from_dict(_deserialize(data)) class InternalContext(object): """Used by ConsumerBase as a private context for - methods.""" def __init__(self, proxy): self.proxy = proxy self.msg_waiter = None def _get_response(self, ctx, proxy, topic, data): """Process a curried message and cast the result to topic.""" LOG.debug(_("Running func with context: %s"), ctx.to_dict()) data.setdefault('version', None) data.setdefault('args', {}) try: result = proxy.dispatch( ctx, data['version'], data['method'], data.get('namespace'), **data['args']) return ConsumerBase.normalize_reply(result, ctx.replies) except greenlet.GreenletExit: # ignore these since they are just from shutdowns pass except rpc_common.ClientException as e: LOG.debug(_("Expected exception during message handling (%s)") % e._exc_info[1]) return {'exc': rpc_common.serialize_remote_exception(e._exc_info, log_failure=False)} except Exception: LOG.error(_("Exception during message handling")) return {'exc': rpc_common.serialize_remote_exception(sys.exc_info())} def reply(self, ctx, proxy, msg_id=None, context=None, topic=None, msg=None): """Reply to a casted call.""" # NOTE(ewindisch): context kwarg exists for Grizzly compat. # this may be able to be removed earlier than # 'I' if ConsumerBase.process were refactored. if type(msg) is list: payload = msg[-1] else: payload = msg response = ConsumerBase.normalize_reply( self._get_response(ctx, proxy, topic, payload), ctx.replies) LOG.debug(_("Sending reply")) _multi_send(_cast, ctx, topic, { 'method': '-process_reply', 'args': { 'msg_id': msg_id, # Include for Folsom compat. 'response': response } }, _msg_id=msg_id) class ConsumerBase(object): """Base Consumer.""" def __init__(self): self.private_ctx = InternalContext(None) @classmethod def normalize_reply(self, result, replies): #TODO(ewindisch): re-evaluate and document this method. if isinstance(result, types.GeneratorType): return list(result) elif replies: return replies else: return [result] def process(self, proxy, ctx, data): data.setdefault('version', None) data.setdefault('args', {}) # Method starting with - are # processed internally. (non-valid method name) method = data.get('method') if not method: LOG.error(_("RPC message did not include method.")) return # Internal method # uses internal context for safety. if method == '-reply': self.private_ctx.reply(ctx, proxy, **data['args']) return proxy.dispatch(ctx, data['version'], data['method'], data.get('namespace'), **data['args']) class ZmqBaseReactor(ConsumerBase): """A consumer class implementing a centralized casting broker (PULL-PUSH). Used for RoundRobin requests. """ def __init__(self, conf): super(ZmqBaseReactor, self).__init__() self.proxies = {} self.threads = [] self.sockets = [] self.subscribe = {} self.pool = eventlet.greenpool.GreenPool(conf.rpc_thread_pool_size) def register(self, proxy, in_addr, zmq_type_in, in_bind=True, subscribe=None): LOG.info(_("Registering reactor")) if zmq_type_in not in (zmq.PULL, zmq.SUB): raise RPCException("Bad input socktype") # Items push in. inq = ZmqSocket(in_addr, zmq_type_in, bind=in_bind, subscribe=subscribe) self.proxies[inq] = proxy self.sockets.append(inq) LOG.info(_("In reactor registered")) def consume_in_thread(self): @excutils.forever_retry_uncaught_exceptions def _consume(sock): LOG.info(_("Consuming socket")) while True: self.consume(sock) for k in self.proxies.keys(): self.threads.append( self.pool.spawn(_consume, k) ) def wait(self): for t in self.threads: t.wait() def close(self): for s in self.sockets: s.close() for t in self.threads: t.kill() class ZmqProxy(ZmqBaseReactor): """A consumer class implementing a topic-based proxy. Forwards to IPC sockets. """ def __init__(self, conf): super(ZmqProxy, self).__init__(conf) pathsep = set((os.path.sep or '', os.path.altsep or '', '/', '\\')) self.badchars = re.compile(r'[%s]' % re.escape(''.join(pathsep))) self.topic_proxy = {} def consume(self, sock): ipc_dir = CONF.rpc_zmq_ipc_dir data = sock.recv(copy=False) topic = data[1].bytes if topic.startswith('fanout~'): sock_type = zmq.PUB topic = topic.split('.', 1)[0] elif topic.startswith('zmq_replies'): sock_type = zmq.PUB else: sock_type = zmq.PUSH if topic not in self.topic_proxy: def publisher(waiter): LOG.info(_("Creating proxy for topic: %s"), topic) try: # The topic is received over the network, # don't trust this input. if self.badchars.search(topic) is not None: emsg = _("Topic contained dangerous characters.") LOG.warn(emsg) raise RPCException(emsg) out_sock = ZmqSocket("ipc://%s/zmq_topic_%s" % (ipc_dir, topic), sock_type, bind=True) except RPCException: waiter.send_exception(*sys.exc_info()) return self.topic_proxy[topic] = eventlet.queue.LightQueue( CONF.rpc_zmq_topic_backlog) self.sockets.append(out_sock) # It takes some time for a pub socket to open, # before we can have any faith in doing a send() to it. if sock_type == zmq.PUB: eventlet.sleep(.5) waiter.send(True) while(True): data = self.topic_proxy[topic].get() out_sock.send(data, copy=False) wait_sock_creation = eventlet.event.Event() eventlet.spawn(publisher, wait_sock_creation) try: wait_sock_creation.wait() except RPCException: LOG.error(_("Topic socket file creation failed.")) return try: self.topic_proxy[topic].put_nowait(data) except eventlet.queue.Full: LOG.error(_("Local per-topic backlog buffer full for topic " "%(topic)s. Dropping message.") % {'topic': topic}) def consume_in_thread(self): """Runs the ZmqProxy service.""" ipc_dir = CONF.rpc_zmq_ipc_dir consume_in = "tcp://%s:%s" % \ (CONF.rpc_zmq_bind_address, CONF.rpc_zmq_port) consumption_proxy = InternalContext(None) try: os.makedirs(ipc_dir) except os.error: if not os.path.isdir(ipc_dir): with excutils.save_and_reraise_exception(): LOG.error(_("Required IPC directory does not exist at" " %s") % (ipc_dir, )) try: self.register(consumption_proxy, consume_in, zmq.PULL) except zmq.ZMQError: if os.access(ipc_dir, os.X_OK): with excutils.save_and_reraise_exception(): LOG.error(_("Permission denied to IPC directory at" " %s") % (ipc_dir, )) with excutils.save_and_reraise_exception(): LOG.error(_("Could not create ZeroMQ receiver daemon. " "Socket may already be in use.")) super(ZmqProxy, self).consume_in_thread() def unflatten_envelope(packenv): """Unflattens the RPC envelope. Takes a list and returns a dictionary. i.e. [1,2,3,4] => {1: 2, 3: 4} """ i = iter(packenv) h = {} try: while True: k = six.next(i) h[k] = six.next(i) except StopIteration: return h class ZmqReactor(ZmqBaseReactor): """A consumer class implementing a consumer for messages. Can also be used as a 1:1 proxy """ def __init__(self, conf): super(ZmqReactor, self).__init__(conf) def consume(self, sock): #TODO(ewindisch): use zero-copy (i.e. references, not copying) data = sock.recv() LOG.debug(_("CONSUMER RECEIVED DATA: %s"), data) proxy = self.proxies[sock] if data[2] == 'cast': # Legacy protocol packenv = data[3] ctx, msg = _deserialize(packenv) request = rpc_common.deserialize_msg(msg) ctx = RpcContext.unmarshal(ctx) elif data[2] == 'impl_zmq_v2': packenv = data[4:] msg = unflatten_envelope(packenv) request = rpc_common.deserialize_msg(msg) # Unmarshal only after verifying the message. ctx = RpcContext.unmarshal(data[3]) else: LOG.error(_("ZMQ Envelope version unsupported or unknown.")) return self.pool.spawn_n(self.process, proxy, ctx, request) class Connection(rpc_common.Connection): """Manages connections and threads.""" def __init__(self, conf): self.topics = [] self.reactor = ZmqReactor(conf) def create_consumer(self, topic, proxy, fanout=False): # Register with matchmaker. _get_matchmaker().register(topic, CONF.rpc_zmq_host) # Subscription scenarios if fanout: sock_type = zmq.SUB subscribe = ('', fanout)[type(fanout) == str] topic = 'fanout~' + topic.split('.', 1)[0] else: sock_type = zmq.PULL subscribe = None topic = '.'.join((topic.split('.', 1)[0], CONF.rpc_zmq_host)) if topic in self.topics: LOG.info(_("Skipping topic registration. Already registered.")) return # Receive messages from (local) proxy inaddr = "ipc://%s/zmq_topic_%s" % \ (CONF.rpc_zmq_ipc_dir, topic) LOG.debug(_("Consumer is a zmq.%s"), ['PULL', 'SUB'][sock_type == zmq.SUB]) self.reactor.register(proxy, inaddr, sock_type, subscribe=subscribe, in_bind=False) self.topics.append(topic) def close(self): _get_matchmaker().stop_heartbeat() for topic in self.topics: _get_matchmaker().unregister(topic, CONF.rpc_zmq_host) self.reactor.close() self.topics = [] def wait(self): self.reactor.wait() def consume_in_thread(self): _get_matchmaker().start_heartbeat() self.reactor.consume_in_thread() def _cast(addr, context, topic, msg, timeout=None, envelope=False, _msg_id=None): timeout_cast = timeout or CONF.rpc_cast_timeout payload = [RpcContext.marshal(context), msg] with Timeout(timeout_cast, exception=rpc_common.Timeout): try: conn = ZmqClient(addr) # assumes cast can't return an exception conn.cast(_msg_id, topic, payload, envelope) except zmq.ZMQError: raise RPCException("Cast failed. ZMQ Socket Exception") finally: if 'conn' in vars(): conn.close() def _call(addr, context, topic, msg, timeout=None, envelope=False): # timeout_response is how long we wait for a response timeout = timeout or CONF.rpc_response_timeout # The msg_id is used to track replies. msg_id = uuid.uuid4().hex # Replies always come into the reply service. reply_topic = "zmq_replies.%s" % CONF.rpc_zmq_host LOG.debug(_("Creating payload")) # Curry the original request into a reply method. mcontext = RpcContext.marshal(context) payload = { 'method': '-reply', 'args': { 'msg_id': msg_id, 'topic': reply_topic, # TODO(ewindisch): safe to remove mcontext in I. 'msg': [mcontext, msg] } } LOG.debug(_("Creating queue socket for reply waiter")) # Messages arriving async. # TODO(ewindisch): have reply consumer with dynamic subscription mgmt with Timeout(timeout, exception=rpc_common.Timeout): try: msg_waiter = ZmqSocket( "ipc://%s/zmq_topic_zmq_replies.%s" % (CONF.rpc_zmq_ipc_dir, CONF.rpc_zmq_host), zmq.SUB, subscribe=msg_id, bind=False ) LOG.debug(_("Sending cast")) _cast(addr, context, topic, payload, envelope) LOG.debug(_("Cast sent; Waiting reply")) # Blocks until receives reply msg = msg_waiter.recv() LOG.debug(_("Received message: %s"), msg) LOG.debug(_("Unpacking response")) if msg[2] == 'cast': # Legacy version raw_msg = _deserialize(msg[-1])[-1] elif msg[2] == 'impl_zmq_v2': rpc_envelope = unflatten_envelope(msg[4:]) raw_msg = rpc_common.deserialize_msg(rpc_envelope) else: raise rpc_common.UnsupportedRpcEnvelopeVersion( _("Unsupported or unknown ZMQ envelope returned.")) responses = raw_msg['args']['response'] # ZMQError trumps the Timeout error. except zmq.ZMQError: raise RPCException("ZMQ Socket Error") except (IndexError, KeyError): raise RPCException(_("RPC Message Invalid.")) finally: if 'msg_waiter' in vars(): msg_waiter.close() # It seems we don't need to do all of the following, # but perhaps it would be useful for multicall? # One effect of this is that we're checking all # responses for Exceptions. for resp in responses: if isinstance(resp, types.DictType) and 'exc' in resp: raise rpc_common.deserialize_remote_exception(CONF, resp['exc']) return responses[-1] def _multi_send(method, context, topic, msg, timeout=None, envelope=False, _msg_id=None): """Wraps the sending of messages. Dispatches to the matchmaker and sends message to all relevant hosts. """ conf = CONF LOG.debug(_("%(msg)s") % {'msg': ' '.join(map(pformat, (topic, msg)))}) queues = _get_matchmaker().queues(topic) LOG.debug(_("Sending message(s) to: %s"), queues) # Don't stack if we have no matchmaker results if not queues: LOG.warn(_("No matchmaker results. Not casting.")) # While not strictly a timeout, callers know how to handle # this exception and a timeout isn't too big a lie. raise rpc_common.Timeout(_("No match from matchmaker.")) # This supports brokerless fanout (addresses > 1) for queue in queues: (_topic, ip_addr) = queue _addr = "tcp://%s:%s" % (ip_addr, conf.rpc_zmq_port) if method.__name__ == '_cast': eventlet.spawn_n(method, _addr, context, _topic, msg, timeout, envelope, _msg_id) return return method(_addr, context, _topic, msg, timeout, envelope) def create_connection(conf, new=True): return Connection(conf) def multicall(conf, *args, **kwargs): """Multiple calls.""" return _multi_send(_call, *args, **kwargs) def call(conf, *args, **kwargs): """Send a message, expect a response.""" data = _multi_send(_call, *args, **kwargs) return data[-1] def cast(conf, *args, **kwargs): """Send a message expecting no reply.""" _multi_send(_cast, *args, **kwargs) def fanout_cast(conf, context, topic, msg, **kwargs): """Send a message to all listening and expect no reply.""" # NOTE(ewindisch): fanout~ is used because it avoid splitting on . # and acts as a non-subtle hint to the matchmaker and ZmqProxy. _multi_send(_cast, context, 'fanout~' + str(topic), msg, **kwargs) def notify(conf, context, topic, msg, envelope): """Send notification event. Notifications are sent to topic-priority. This differs from the AMQP drivers which send to topic.priority. """ # NOTE(ewindisch): dot-priority in rpc notifier does not # work with our assumptions. topic = topic.replace('.', '-') cast(conf, context, topic, msg, envelope=envelope) def cleanup(): """Clean up resources in use by implementation.""" global ZMQ_CTX if ZMQ_CTX: ZMQ_CTX.term() ZMQ_CTX = None global matchmaker matchmaker = None def _get_ctxt(): if not zmq: raise ImportError("Failed to import eventlet.green.zmq") global ZMQ_CTX if not ZMQ_CTX: ZMQ_CTX = zmq.Context(CONF.rpc_zmq_contexts) return ZMQ_CTX def _get_matchmaker(*args, **kwargs): global matchmaker if not matchmaker: mm = CONF.rpc_zmq_matchmaker if mm.endswith('matchmaker.MatchMakerRing'): mm.replace('matchmaker', 'matchmaker_ring') LOG.warn(_('rpc_zmq_matchmaker = %(orig)s is deprecated; use' ' %(new)s instead') % dict( orig=CONF.rpc_zmq_matchmaker, new=mm)) matchmaker = importutils.import_object(mm, *args, **kwargs) return matchmaker heat-2014.1.5/heat/openstack/common/rpc/matchmaker_ring.py0000664000567000056700000000667712540642614024542 0ustar jenkinsjenkins00000000000000# Copyright 2011-2013 Cloudscaling Group, Inc # # 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. """ The MatchMaker classes should except a Topic or Fanout exchange key and return keys for direct exchanges, per (approximate) AMQP parlance. """ import itertools import json from oslo.config import cfg from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.rpc import matchmaker as mm matchmaker_opts = [ # Matchmaker ring file cfg.StrOpt('ringfile', deprecated_name='matchmaker_ringfile', deprecated_group='DEFAULT', default='/etc/oslo/matchmaker_ring.json', help='Matchmaker ring file (JSON)'), ] CONF = cfg.CONF CONF.register_opts(matchmaker_opts, 'matchmaker_ring') LOG = logging.getLogger(__name__) class RingExchange(mm.Exchange): """Match Maker where hosts are loaded from a static JSON formatted file. __init__ takes optional ring dictionary argument, otherwise loads the ringfile from CONF.mathcmaker_ringfile. """ def __init__(self, ring=None): super(RingExchange, self).__init__() if ring: self.ring = ring else: fh = open(CONF.matchmaker_ring.ringfile, 'r') self.ring = json.load(fh) fh.close() self.ring0 = {} for k in self.ring.keys(): self.ring0[k] = itertools.cycle(self.ring[k]) def _ring_has(self, key): return key in self.ring0 class RoundRobinRingExchange(RingExchange): """A Topic Exchange based on a hashmap.""" def __init__(self, ring=None): super(RoundRobinRingExchange, self).__init__(ring) def run(self, key): if not self._ring_has(key): LOG.warn( _("No key defining hosts for topic '%s', " "see ringfile") % (key, ) ) return [] host = next(self.ring0[key]) return [(key + '.' + host, host)] class FanoutRingExchange(RingExchange): """Fanout Exchange based on a hashmap.""" def __init__(self, ring=None): super(FanoutRingExchange, self).__init__(ring) def run(self, key): # Assume starts with "fanout~", strip it for lookup. nkey = key.split('fanout~')[1:][0] if not self._ring_has(nkey): LOG.warn( _("No key defining hosts for topic '%s', " "see ringfile") % (nkey, ) ) return [] return map(lambda x: (key + '.' + x, x), self.ring[nkey]) class MatchMakerRing(mm.MatchMakerBase): """Match Maker where hosts are loaded from a static hashmap.""" def __init__(self, ring=None): super(MatchMakerRing, self).__init__() self.add_binding(mm.FanoutBinding(), FanoutRingExchange(ring)) self.add_binding(mm.DirectBinding(), mm.DirectExchange()) self.add_binding(mm.TopicBinding(), RoundRobinRingExchange(ring)) heat-2014.1.5/heat/openstack/common/rpc/serializer.py0000664000567000056700000000311412540642614023537 0ustar jenkinsjenkins00000000000000# Copyright 2013 IBM Corp. # # 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. """Provides the definition of an RPC serialization handler""" import abc import six @six.add_metaclass(abc.ABCMeta) class Serializer(object): """Generic (de-)serialization definition base class.""" @abc.abstractmethod def serialize_entity(self, context, entity): """Serialize something to primitive form. :param context: Security context :param entity: Entity to be serialized :returns: Serialized form of entity """ pass @abc.abstractmethod def deserialize_entity(self, context, entity): """Deserialize something from primitive form. :param context: Security context :param entity: Primitive to be deserialized :returns: Deserialized form of entity """ pass class NoOpSerializer(Serializer): """A serializer that does nothing.""" def serialize_entity(self, context, entity): return entity def deserialize_entity(self, context, entity): return entity heat-2014.1.5/heat/openstack/common/rpc/matchmaker.py0000664000567000056700000002230212540642614023502 0ustar jenkinsjenkins00000000000000# Copyright 2011 Cloudscaling Group, Inc # # 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. """ The MatchMaker classes should except a Topic or Fanout exchange key and return keys for direct exchanges, per (approximate) AMQP parlance. """ import contextlib import eventlet from oslo.config import cfg from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging matchmaker_opts = [ cfg.IntOpt('matchmaker_heartbeat_freq', default=300, help='Heartbeat frequency'), cfg.IntOpt('matchmaker_heartbeat_ttl', default=600, help='Heartbeat time-to-live.'), ] CONF = cfg.CONF CONF.register_opts(matchmaker_opts) LOG = logging.getLogger(__name__) contextmanager = contextlib.contextmanager class MatchMakerException(Exception): """Signified a match could not be found.""" message = _("Match not found by MatchMaker.") class Exchange(object): """Implements lookups. Subclass this to support hashtables, dns, etc. """ def __init__(self): pass def run(self, key): raise NotImplementedError() class Binding(object): """A binding on which to perform a lookup.""" def __init__(self): pass def test(self, key): raise NotImplementedError() class MatchMakerBase(object): """Match Maker Base Class. Build off HeartbeatMatchMakerBase if building a heartbeat-capable MatchMaker. """ def __init__(self): # Array of tuples. Index [2] toggles negation, [3] is last-if-true self.bindings = [] self.no_heartbeat_msg = _('Matchmaker does not implement ' 'registration or heartbeat.') def register(self, key, host): """Register a host on a backend. Heartbeats, if applicable, may keepalive registration. """ pass def ack_alive(self, key, host): """Acknowledge that a key.host is alive. Used internally for updating heartbeats, but may also be used publicly to acknowledge a system is alive (i.e. rpc message successfully sent to host) """ pass def is_alive(self, topic, host): """Checks if a host is alive.""" pass def expire(self, topic, host): """Explicitly expire a host's registration.""" pass def send_heartbeats(self): """Send all heartbeats. Use start_heartbeat to spawn a heartbeat greenthread, which loops this method. """ pass def unregister(self, key, host): """Unregister a topic.""" pass def start_heartbeat(self): """Spawn heartbeat greenthread.""" pass def stop_heartbeat(self): """Destroys the heartbeat greenthread.""" pass def add_binding(self, binding, rule, last=True): self.bindings.append((binding, rule, False, last)) #NOTE(ewindisch): kept the following method in case we implement the # underlying support. #def add_negate_binding(self, binding, rule, last=True): # self.bindings.append((binding, rule, True, last)) def queues(self, key): workers = [] # bit is for negate bindings - if we choose to implement it. # last stops processing rules if this matches. for (binding, exchange, bit, last) in self.bindings: if binding.test(key): workers.extend(exchange.run(key)) # Support last. if last: return workers return workers class HeartbeatMatchMakerBase(MatchMakerBase): """Base for a heart-beat capable MatchMaker. Provides common methods for registering, unregistering, and maintaining heartbeats. """ def __init__(self): self.hosts = set() self._heart = None self.host_topic = {} super(HeartbeatMatchMakerBase, self).__init__() def send_heartbeats(self): """Send all heartbeats. Use start_heartbeat to spawn a heartbeat greenthread, which loops this method. """ for key, host in self.host_topic: self.ack_alive(key, host) def ack_alive(self, key, host): """Acknowledge that a host.topic is alive. Used internally for updating heartbeats, but may also be used publicly to acknowledge a system is alive (i.e. rpc message successfully sent to host) """ raise NotImplementedError("Must implement ack_alive") def backend_register(self, key, host): """Implements registration logic. Called by register(self,key,host) """ raise NotImplementedError("Must implement backend_register") def backend_unregister(self, key, key_host): """Implements de-registration logic. Called by unregister(self,key,host) """ raise NotImplementedError("Must implement backend_unregister") def register(self, key, host): """Register a host on a backend. Heartbeats, if applicable, may keepalive registration. """ self.hosts.add(host) self.host_topic[(key, host)] = host key_host = '.'.join((key, host)) self.backend_register(key, key_host) self.ack_alive(key, host) def unregister(self, key, host): """Unregister a topic.""" if (key, host) in self.host_topic: del self.host_topic[(key, host)] self.hosts.discard(host) self.backend_unregister(key, '.'.join((key, host))) LOG.info(_("Matchmaker unregistered: %(key)s, %(host)s"), {'key': key, 'host': host}) def start_heartbeat(self): """Implementation of MatchMakerBase.start_heartbeat. Launches greenthread looping send_heartbeats(), yielding for CONF.matchmaker_heartbeat_freq seconds between iterations. """ if not self.hosts: raise MatchMakerException( _("Register before starting heartbeat.")) def do_heartbeat(): while True: self.send_heartbeats() eventlet.sleep(CONF.matchmaker_heartbeat_freq) self._heart = eventlet.spawn(do_heartbeat) def stop_heartbeat(self): """Destroys the heartbeat greenthread.""" if self._heart: self._heart.kill() class DirectBinding(Binding): """Specifies a host in the key via a '.' character. Although dots are used in the key, the behavior here is that it maps directly to a host, thus direct. """ def test(self, key): return '.' in key class TopicBinding(Binding): """Where a 'bare' key without dots. AMQP generally considers topic exchanges to be those *with* dots, but we deviate here in terminology as the behavior here matches that of a topic exchange (whereas where there are dots, behavior matches that of a direct exchange. """ def test(self, key): return '.' not in key class FanoutBinding(Binding): """Match on fanout keys, where key starts with 'fanout.' string.""" def test(self, key): return key.startswith('fanout~') class StubExchange(Exchange): """Exchange that does nothing.""" def run(self, key): return [(key, None)] class LocalhostExchange(Exchange): """Exchange where all direct topics are local.""" def __init__(self, host='localhost'): self.host = host super(Exchange, self).__init__() def run(self, key): return [('.'.join((key.split('.')[0], self.host)), self.host)] class DirectExchange(Exchange): """Exchange where all topic keys are split, sending to second half. i.e. "compute.host" sends a message to "compute.host" running on "host" """ def __init__(self): super(Exchange, self).__init__() def run(self, key): e = key.split('.', 1)[1] return [(key, e)] class MatchMakerLocalhost(MatchMakerBase): """Match Maker where all bare topics resolve to localhost. Useful for testing. """ def __init__(self, host='localhost'): super(MatchMakerLocalhost, self).__init__() self.add_binding(FanoutBinding(), LocalhostExchange(host)) self.add_binding(DirectBinding(), DirectExchange()) self.add_binding(TopicBinding(), LocalhostExchange(host)) class MatchMakerStub(MatchMakerBase): """Match Maker where topics are untouched. Useful for testing, or for AMQP/brokered queues. Will not work where knowledge of hosts is known (i.e. zeromq) """ def __init__(self): super(MatchMakerStub, self).__init__() self.add_binding(FanoutBinding(), StubExchange()) self.add_binding(DirectBinding(), StubExchange()) self.add_binding(TopicBinding(), StubExchange()) heat-2014.1.5/heat/openstack/common/rpc/impl_fake.py0000664000567000056700000001332412540642614023321 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack Foundation # # 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. """Fake RPC implementation which calls proxy methods directly with no queues. Casts will block, but this is very useful for tests. """ import inspect # NOTE(russellb): We specifically want to use json, not our own jsonutils. # jsonutils has some extra logic to automatically convert objects to primitive # types so that they can be serialized. We want to catch all cases where # non-primitive types make it into this code and treat it as an error. import json import time import eventlet import six from heat.openstack.common.rpc import common as rpc_common CONSUMERS = {} class RpcContext(rpc_common.CommonRpcContext): def __init__(self, **kwargs): super(RpcContext, self).__init__(**kwargs) self._response = [] self._done = False def deepcopy(self): values = self.to_dict() new_inst = self.__class__(**values) new_inst._response = self._response new_inst._done = self._done return new_inst def reply(self, reply=None, failure=None, ending=False): if ending: self._done = True if not self._done: self._response.append((reply, failure)) class Consumer(object): def __init__(self, topic, proxy): self.topic = topic self.proxy = proxy def call(self, context, version, method, namespace, args, timeout): done = eventlet.event.Event() def _inner(): ctxt = RpcContext.from_dict(context.to_dict()) try: rval = self.proxy.dispatch(context, version, method, namespace, **args) res = [] # Caller might have called ctxt.reply() manually for (reply, failure) in ctxt._response: if failure: six.reraise(failure[0], failure[1], failure[2]) res.append(reply) # if ending not 'sent'...we might have more data to # return from the function itself if not ctxt._done: if inspect.isgenerator(rval): for val in rval: res.append(val) else: res.append(rval) done.send(res) except rpc_common.ClientException as e: done.send_exception(e._exc_info[1]) except Exception as e: done.send_exception(e) thread = eventlet.greenthread.spawn(_inner) if timeout: start_time = time.time() while not done.ready(): eventlet.greenthread.sleep(1) cur_time = time.time() if (cur_time - start_time) > timeout: thread.kill() raise rpc_common.Timeout() return done.wait() class Connection(object): """Connection object.""" def __init__(self): self.consumers = [] def create_consumer(self, topic, proxy, fanout=False): consumer = Consumer(topic, proxy) self.consumers.append(consumer) if topic not in CONSUMERS: CONSUMERS[topic] = [] CONSUMERS[topic].append(consumer) def close(self): for consumer in self.consumers: CONSUMERS[consumer.topic].remove(consumer) self.consumers = [] def consume_in_thread(self): pass def create_connection(conf, new=True): """Create a connection.""" return Connection() def check_serialize(msg): """Make sure a message intended for rpc can be serialized.""" json.dumps(msg) def multicall(conf, context, topic, msg, timeout=None): """Make a call that returns multiple times.""" check_serialize(msg) method = msg.get('method') if not method: return args = msg.get('args', {}) version = msg.get('version', None) namespace = msg.get('namespace', None) try: consumer = CONSUMERS[topic][0] except (KeyError, IndexError): raise rpc_common.Timeout("No consumers available") else: return consumer.call(context, version, method, namespace, args, timeout) def call(conf, context, topic, msg, timeout=None): """Sends a message on a topic and wait for a response.""" rv = multicall(conf, context, topic, msg, timeout) # NOTE(vish): return the last result from the multicall rv = list(rv) if not rv: return return rv[-1] def cast(conf, context, topic, msg): check_serialize(msg) try: call(conf, context, topic, msg) except Exception: pass def notify(conf, context, topic, msg, envelope): check_serialize(msg) def cleanup(): pass def fanout_cast(conf, context, topic, msg): """Cast to all consumers of a topic.""" check_serialize(msg) method = msg.get('method') if not method: return args = msg.get('args', {}) version = msg.get('version', None) namespace = msg.get('namespace', None) for consumer in CONSUMERS.get(topic, []): try: consumer.call(context, version, method, namespace, args, None) except Exception: pass heat-2014.1.5/heat/openstack/common/rpc/impl_qpid.py0000664000567000056700000007203712540642614023356 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack Foundation # Copyright 2011 - 2012, Red Hat, Inc. # # 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. import functools import itertools import time import eventlet import greenlet from oslo.config import cfg import six from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import jsonutils from heat.openstack.common import log as logging from heat.openstack.common.rpc import amqp as rpc_amqp from heat.openstack.common.rpc import common as rpc_common qpid_codec = importutils.try_import("qpid.codec010") qpid_messaging = importutils.try_import("qpid.messaging") qpid_exceptions = importutils.try_import("qpid.messaging.exceptions") LOG = logging.getLogger(__name__) qpid_opts = [ cfg.StrOpt('qpid_hostname', default='localhost', help='Qpid broker hostname'), cfg.IntOpt('qpid_port', default=5672, help='Qpid broker port'), cfg.ListOpt('qpid_hosts', default=['$qpid_hostname:$qpid_port'], help='Qpid HA cluster host:port pairs'), cfg.StrOpt('qpid_username', default='', help='Username for qpid connection'), cfg.StrOpt('qpid_password', default='', help='Password for qpid connection', secret=True), cfg.StrOpt('qpid_sasl_mechanisms', default='', help='Space separated list of SASL mechanisms to use for auth'), cfg.IntOpt('qpid_heartbeat', default=60, help='Seconds between connection keepalive heartbeats'), cfg.StrOpt('qpid_protocol', default='tcp', help="Transport to use, either 'tcp' or 'ssl'"), cfg.BoolOpt('qpid_tcp_nodelay', default=True, help='Disable Nagle algorithm'), # NOTE(russellb) If any additional versions are added (beyond 1 and 2), # this file could probably use some additional refactoring so that the # differences between each version are split into different classes. cfg.IntOpt('qpid_topology_version', default=1, help="The qpid topology version to use. Version 1 is what " "was originally used by impl_qpid. Version 2 includes " "some backwards-incompatible changes that allow broker " "federation to work. Users should update to version 2 " "when they are able to take everything down, as it " "requires a clean break."), ] cfg.CONF.register_opts(qpid_opts) JSON_CONTENT_TYPE = 'application/json; charset=utf8' def raise_invalid_topology_version(conf): msg = (_("Invalid value for qpid_topology_version: %d") % conf.qpid_topology_version) LOG.error(msg) raise Exception(msg) class ConsumerBase(object): """Consumer base class.""" def __init__(self, conf, session, callback, node_name, node_opts, link_name, link_opts): """Declare a queue on an amqp session. 'session' is the amqp session to use 'callback' is the callback to call when messages are received 'node_name' is the first part of the Qpid address string, before ';' 'node_opts' will be applied to the "x-declare" section of "node" in the address string. 'link_name' goes into the "name" field of the "link" in the address string 'link_opts' will be applied to the "x-declare" section of "link" in the address string. """ self.callback = callback self.receiver = None self.session = None if conf.qpid_topology_version == 1: addr_opts = { "create": "always", "node": { "type": "topic", "x-declare": { "durable": True, "auto-delete": True, }, }, "link": { "durable": True, "x-declare": { "durable": False, "auto-delete": True, "exclusive": False, }, }, } addr_opts["node"]["x-declare"].update(node_opts) elif conf.qpid_topology_version == 2: addr_opts = { "link": { "x-declare": { "auto-delete": True, "exclusive": False, }, }, } else: raise_invalid_topology_version() addr_opts["link"]["x-declare"].update(link_opts) if link_name: addr_opts["link"]["name"] = link_name self.address = "%s ; %s" % (node_name, jsonutils.dumps(addr_opts)) self.connect(session) def connect(self, session): """Declare the receiver on connect.""" self._declare_receiver(session) def reconnect(self, session): """Re-declare the receiver after a qpid reconnect.""" self._declare_receiver(session) def _declare_receiver(self, session): self.session = session self.receiver = session.receiver(self.address) self.receiver.capacity = 1 def _unpack_json_msg(self, msg): """Load the JSON data in msg if msg.content_type indicates that it is necessary. Put the loaded data back into msg.content and update msg.content_type appropriately. A Qpid Message containing a dict will have a content_type of 'amqp/map', whereas one containing a string that needs to be converted back from JSON will have a content_type of JSON_CONTENT_TYPE. :param msg: a Qpid Message object :returns: None """ if msg.content_type == JSON_CONTENT_TYPE: msg.content = jsonutils.loads(msg.content) msg.content_type = 'amqp/map' def consume(self): """Fetch the message and pass it to the callback object.""" message = self.receiver.fetch() try: self._unpack_json_msg(message) msg = rpc_common.deserialize_msg(message.content) self.callback(msg) except Exception: LOG.exception(_("Failed to process message... skipping it.")) finally: # TODO(sandy): Need support for optional ack_on_error. self.session.acknowledge(message) def get_receiver(self): return self.receiver def get_node_name(self): return self.address.split(';')[0] class DirectConsumer(ConsumerBase): """Queue/consumer class for 'direct'.""" def __init__(self, conf, session, msg_id, callback): """Init a 'direct' queue. 'session' is the amqp session to use 'msg_id' is the msg_id to listen on 'callback' is the callback to call when messages are received """ link_opts = { "auto-delete": conf.amqp_auto_delete, "exclusive": True, "durable": conf.amqp_durable_queues, } if conf.qpid_topology_version == 1: node_name = "%s/%s" % (msg_id, msg_id) node_opts = {"type": "direct"} link_name = msg_id elif conf.qpid_topology_version == 2: node_name = "amq.direct/%s" % msg_id node_opts = {} link_name = None else: raise_invalid_topology_version() super(DirectConsumer, self).__init__(conf, session, callback, node_name, node_opts, link_name, link_opts) class TopicConsumer(ConsumerBase): """Consumer class for 'topic'.""" def __init__(self, conf, session, topic, callback, name=None, exchange_name=None): """Init a 'topic' queue. :param session: the amqp session to use :param topic: is the topic to listen on :paramtype topic: str :param callback: the callback to call when messages are received :param name: optional queue name, defaults to topic """ exchange_name = exchange_name or rpc_amqp.get_control_exchange(conf) link_opts = { "auto-delete": conf.amqp_auto_delete, "durable": conf.amqp_durable_queues, } if conf.qpid_topology_version == 1: node_name = "%s/%s" % (exchange_name, topic) elif conf.qpid_topology_version == 2: node_name = "amq.topic/topic/%s/%s" % (exchange_name, topic) else: raise_invalid_topology_version() super(TopicConsumer, self).__init__(conf, session, callback, node_name, {}, name or topic, link_opts) class FanoutConsumer(ConsumerBase): """Consumer class for 'fanout'.""" def __init__(self, conf, session, topic, callback): """Init a 'fanout' queue. 'session' is the amqp session to use 'topic' is the topic to listen on 'callback' is the callback to call when messages are received """ self.conf = conf link_opts = {"exclusive": True} if conf.qpid_topology_version == 1: node_name = "%s_fanout" % topic node_opts = {"durable": False, "type": "fanout"} elif conf.qpid_topology_version == 2: node_name = "amq.topic/fanout/%s" % topic node_opts = {} else: raise_invalid_topology_version() super(FanoutConsumer, self).__init__(conf, session, callback, node_name, node_opts, None, link_opts) class Publisher(object): """Base Publisher class.""" def __init__(self, conf, session, node_name, node_opts=None): """Init the Publisher class with the exchange_name, routing_key, and other options """ self.sender = None self.session = session if conf.qpid_topology_version == 1: addr_opts = { "create": "always", "node": { "type": "topic", "x-declare": { "durable": False, # auto-delete isn't implemented for exchanges in qpid, # but put in here anyway "auto-delete": True, }, }, } if node_opts: addr_opts["node"]["x-declare"].update(node_opts) self.address = "%s ; %s" % (node_name, jsonutils.dumps(addr_opts)) elif conf.qpid_topology_version == 2: self.address = node_name else: raise_invalid_topology_version() self.reconnect(session) def reconnect(self, session): """Re-establish the Sender after a reconnection.""" self.sender = session.sender(self.address) def _pack_json_msg(self, msg): """Qpid cannot serialize dicts containing strings longer than 65535 characters. This function dumps the message content to a JSON string, which Qpid is able to handle. :param msg: May be either a Qpid Message object or a bare dict. :returns: A Qpid Message with its content field JSON encoded. """ try: msg.content = jsonutils.dumps(msg.content) except AttributeError: # Need to have a Qpid message so we can set the content_type. msg = qpid_messaging.Message(jsonutils.dumps(msg)) msg.content_type = JSON_CONTENT_TYPE return msg def send(self, msg): """Send a message.""" try: # Check if Qpid can encode the message check_msg = msg if not hasattr(check_msg, 'content_type'): check_msg = qpid_messaging.Message(msg) content_type = check_msg.content_type enc, dec = qpid_messaging.message.get_codec(content_type) enc(check_msg.content) except qpid_codec.CodecException: # This means the message couldn't be serialized as a dict. msg = self._pack_json_msg(msg) self.sender.send(msg) class DirectPublisher(Publisher): """Publisher class for 'direct'.""" def __init__(self, conf, session, msg_id): """Init a 'direct' publisher.""" if conf.qpid_topology_version == 1: node_name = "%s/%s" % (msg_id, msg_id) node_opts = {"type": "direct"} elif conf.qpid_topology_version == 2: node_name = "amq.direct/%s" % msg_id node_opts = {} else: raise_invalid_topology_version() super(DirectPublisher, self).__init__(conf, session, node_name, node_opts) class TopicPublisher(Publisher): """Publisher class for 'topic'.""" def __init__(self, conf, session, topic): """Init a 'topic' publisher. """ exchange_name = rpc_amqp.get_control_exchange(conf) if conf.qpid_topology_version == 1: node_name = "%s/%s" % (exchange_name, topic) elif conf.qpid_topology_version == 2: node_name = "amq.topic/topic/%s/%s" % (exchange_name, topic) else: raise_invalid_topology_version() super(TopicPublisher, self).__init__(conf, session, node_name) class FanoutPublisher(Publisher): """Publisher class for 'fanout'.""" def __init__(self, conf, session, topic): """Init a 'fanout' publisher. """ if conf.qpid_topology_version == 1: node_name = "%s_fanout" % topic node_opts = {"type": "fanout"} elif conf.qpid_topology_version == 2: node_name = "amq.topic/fanout/%s" % topic node_opts = {} else: raise_invalid_topology_version() super(FanoutPublisher, self).__init__(conf, session, node_name, node_opts) class NotifyPublisher(Publisher): """Publisher class for notifications.""" def __init__(self, conf, session, topic): """Init a 'topic' publisher. """ exchange_name = rpc_amqp.get_control_exchange(conf) node_opts = {"durable": True} if conf.qpid_topology_version == 1: node_name = "%s/%s" % (exchange_name, topic) elif conf.qpid_topology_version == 2: node_name = "amq.topic/topic/%s/%s" % (exchange_name, topic) else: raise_invalid_topology_version() super(NotifyPublisher, self).__init__(conf, session, node_name, node_opts) class Connection(object): """Connection object.""" pool = None def __init__(self, conf, server_params=None): if not qpid_messaging: raise ImportError("Failed to import qpid.messaging") self.session = None self.consumers = {} self.consumer_thread = None self.proxy_callbacks = [] self.conf = conf if server_params and 'hostname' in server_params: # NOTE(russellb) This enables support for cast_to_server. server_params['qpid_hosts'] = [ '%s:%d' % (server_params['hostname'], server_params.get('port', 5672)) ] params = { 'qpid_hosts': self.conf.qpid_hosts, 'username': self.conf.qpid_username, 'password': self.conf.qpid_password, } params.update(server_params or {}) self.brokers = params['qpid_hosts'] self.username = params['username'] self.password = params['password'] brokers_count = len(self.brokers) self.next_broker_indices = itertools.cycle(range(brokers_count)) self.connection_create(self.brokers[0]) self.reconnect() def connection_create(self, broker): # Create the connection - this does not open the connection self.connection = qpid_messaging.Connection(broker) # Check if flags are set and if so set them for the connection # before we call open self.connection.username = self.username self.connection.password = self.password self.connection.sasl_mechanisms = self.conf.qpid_sasl_mechanisms # Reconnection is done by self.reconnect() self.connection.reconnect = False self.connection.heartbeat = self.conf.qpid_heartbeat self.connection.transport = self.conf.qpid_protocol self.connection.tcp_nodelay = self.conf.qpid_tcp_nodelay def _register_consumer(self, consumer): self.consumers[str(consumer.get_receiver())] = consumer def _lookup_consumer(self, receiver): return self.consumers[str(receiver)] def reconnect(self): """Handles reconnecting and re-establishing sessions and queues.""" delay = 1 while True: # Close the session if necessary if self.connection.opened(): try: self.connection.close() except qpid_exceptions.ConnectionError: pass broker = self.brokers[next(self.next_broker_indices)] try: self.connection_create(broker) self.connection.open() except qpid_exceptions.ConnectionError as e: msg_dict = dict(e=e, delay=delay) msg = _("Unable to connect to AMQP server: %(e)s. " "Sleeping %(delay)s seconds") % msg_dict LOG.error(msg) time.sleep(delay) delay = min(2 * delay, 60) else: LOG.info(_('Connected to AMQP server on %s'), broker) break self.session = self.connection.session() if self.consumers: consumers = self.consumers self.consumers = {} for consumer in six.itervalues(consumers): consumer.reconnect(self.session) self._register_consumer(consumer) LOG.debug(_("Re-established AMQP queues")) def ensure(self, error_callback, method, *args, **kwargs): while True: try: return method(*args, **kwargs) except (qpid_exceptions.Empty, qpid_exceptions.ConnectionError) as e: if error_callback: error_callback(e) self.reconnect() def close(self): """Close/release this connection.""" self.cancel_consumer_thread() self.wait_on_proxy_callbacks() try: self.connection.close() except Exception: # NOTE(dripton) Logging exceptions that happen during cleanup just # causes confusion; there's really nothing useful we can do with # them. pass self.connection = None def reset(self): """Reset a connection so it can be used again.""" self.cancel_consumer_thread() self.wait_on_proxy_callbacks() self.session.close() self.session = self.connection.session() self.consumers = {} def declare_consumer(self, consumer_cls, topic, callback): """Create a Consumer using the class that was passed in and add it to our list of consumers """ def _connect_error(exc): log_info = {'topic': topic, 'err_str': str(exc)} LOG.error(_("Failed to declare consumer for topic '%(topic)s': " "%(err_str)s") % log_info) def _declare_consumer(): consumer = consumer_cls(self.conf, self.session, topic, callback) self._register_consumer(consumer) return consumer return self.ensure(_connect_error, _declare_consumer) def iterconsume(self, limit=None, timeout=None): """Return an iterator that will consume from all queues/consumers.""" def _error_callback(exc): if isinstance(exc, qpid_exceptions.Empty): LOG.debug(_('Timed out waiting for RPC response: %s') % str(exc)) raise rpc_common.Timeout() else: LOG.exception(_('Failed to consume message from queue: %s') % str(exc)) def _consume(): nxt_receiver = self.session.next_receiver(timeout=timeout) try: self._lookup_consumer(nxt_receiver).consume() except Exception: LOG.exception(_("Error processing message. Skipping it.")) for iteration in itertools.count(0): if limit and iteration >= limit: raise StopIteration yield self.ensure(_error_callback, _consume) def cancel_consumer_thread(self): """Cancel a consumer thread.""" if self.consumer_thread is not None: self.consumer_thread.kill() try: self.consumer_thread.wait() except greenlet.GreenletExit: pass self.consumer_thread = None def wait_on_proxy_callbacks(self): """Wait for all proxy callback threads to exit.""" for proxy_cb in self.proxy_callbacks: proxy_cb.wait() def publisher_send(self, cls, topic, msg): """Send to a publisher based on the publisher class.""" def _connect_error(exc): log_info = {'topic': topic, 'err_str': str(exc)} LOG.exception(_("Failed to publish message to topic " "'%(topic)s': %(err_str)s") % log_info) def _publisher_send(): publisher = cls(self.conf, self.session, topic) publisher.send(msg) return self.ensure(_connect_error, _publisher_send) def declare_direct_consumer(self, topic, callback): """Create a 'direct' queue. In nova's use, this is generally a msg_id queue used for responses for call/multicall """ self.declare_consumer(DirectConsumer, topic, callback) def declare_topic_consumer(self, topic, callback=None, queue_name=None, exchange_name=None): """Create a 'topic' consumer.""" self.declare_consumer(functools.partial(TopicConsumer, name=queue_name, exchange_name=exchange_name, ), topic, callback) def declare_fanout_consumer(self, topic, callback): """Create a 'fanout' consumer.""" self.declare_consumer(FanoutConsumer, topic, callback) def direct_send(self, msg_id, msg): """Send a 'direct' message.""" self.publisher_send(DirectPublisher, msg_id, msg) def topic_send(self, topic, msg, timeout=None): """Send a 'topic' message.""" # # We want to create a message with attributes, e.g. a TTL. We # don't really need to keep 'msg' in its JSON format any longer # so let's create an actual qpid message here and get some # value-add on the go. # # WARNING: Request timeout happens to be in the same units as # qpid's TTL (seconds). If this changes in the future, then this # will need to be altered accordingly. # qpid_message = qpid_messaging.Message(content=msg, ttl=timeout) self.publisher_send(TopicPublisher, topic, qpid_message) def fanout_send(self, topic, msg): """Send a 'fanout' message.""" self.publisher_send(FanoutPublisher, topic, msg) def notify_send(self, topic, msg, **kwargs): """Send a notify message on a topic.""" self.publisher_send(NotifyPublisher, topic, msg) def consume(self, limit=None): """Consume from all queues/consumers.""" it = self.iterconsume(limit=limit) while True: try: six.next(it) except StopIteration: return def consume_in_thread(self): """Consumer from all queues/consumers in a greenthread.""" @excutils.forever_retry_uncaught_exceptions def _consumer_thread(): try: self.consume() except greenlet.GreenletExit: return if self.consumer_thread is None: self.consumer_thread = eventlet.spawn(_consumer_thread) return self.consumer_thread def create_consumer(self, topic, proxy, fanout=False): """Create a consumer that calls a method in a proxy object.""" proxy_cb = rpc_amqp.ProxyCallback( self.conf, proxy, rpc_amqp.get_connection_pool(self.conf, Connection)) self.proxy_callbacks.append(proxy_cb) if fanout: consumer = FanoutConsumer(self.conf, self.session, topic, proxy_cb) else: consumer = TopicConsumer(self.conf, self.session, topic, proxy_cb) self._register_consumer(consumer) return consumer def create_worker(self, topic, proxy, pool_name): """Create a worker that calls a method in a proxy object.""" proxy_cb = rpc_amqp.ProxyCallback( self.conf, proxy, rpc_amqp.get_connection_pool(self.conf, Connection)) self.proxy_callbacks.append(proxy_cb) consumer = TopicConsumer(self.conf, self.session, topic, proxy_cb, name=pool_name) self._register_consumer(consumer) return consumer def join_consumer_pool(self, callback, pool_name, topic, exchange_name=None, ack_on_error=True): """Register as a member of a group of consumers for a given topic from the specified exchange. Exactly one member of a given pool will receive each message. A message will be delivered to multiple pools, if more than one is created. """ callback_wrapper = rpc_amqp.CallbackWrapper( conf=self.conf, callback=callback, connection_pool=rpc_amqp.get_connection_pool(self.conf, Connection), wait_for_consumers=not ack_on_error ) self.proxy_callbacks.append(callback_wrapper) consumer = TopicConsumer(conf=self.conf, session=self.session, topic=topic, callback=callback_wrapper, name=pool_name, exchange_name=exchange_name) self._register_consumer(consumer) return consumer def create_connection(conf, new=True): """Create a connection.""" return rpc_amqp.create_connection( conf, new, rpc_amqp.get_connection_pool(conf, Connection)) def multicall(conf, context, topic, msg, timeout=None): """Make a call that returns multiple times.""" return rpc_amqp.multicall( conf, context, topic, msg, timeout, rpc_amqp.get_connection_pool(conf, Connection)) def call(conf, context, topic, msg, timeout=None): """Sends a message on a topic and wait for a response.""" return rpc_amqp.call( conf, context, topic, msg, timeout, rpc_amqp.get_connection_pool(conf, Connection)) def cast(conf, context, topic, msg): """Sends a message on a topic without waiting for a response.""" return rpc_amqp.cast( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def fanout_cast(conf, context, topic, msg): """Sends a message on a fanout exchange without waiting for a response.""" return rpc_amqp.fanout_cast( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def cast_to_server(conf, context, server_params, topic, msg): """Sends a message on a topic to a specific server.""" return rpc_amqp.cast_to_server( conf, context, server_params, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def fanout_cast_to_server(conf, context, server_params, topic, msg): """Sends a message on a fanout exchange to a specific server.""" return rpc_amqp.fanout_cast_to_server( conf, context, server_params, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def notify(conf, context, topic, msg, envelope): """Sends a notification event on a topic.""" return rpc_amqp.notify(conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection), envelope) def cleanup(): return rpc_amqp.cleanup(Connection.pool) heat-2014.1.5/heat/openstack/common/rpc/zmq_receiver.py0000664000567000056700000000216612540642614024067 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack Foundation # # 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. import eventlet eventlet.monkey_patch() import contextlib import sys from oslo.config import cfg from heat.openstack.common import log as logging from heat.openstack.common import rpc from heat.openstack.common.rpc import impl_zmq CONF = cfg.CONF CONF.register_opts(rpc.rpc_opts) CONF.register_opts(impl_zmq.zmq_opts) def main(): CONF(sys.argv[1:], project='oslo') logging.setup("oslo") with contextlib.closing(impl_zmq.ZmqProxy(CONF)) as reactor: reactor.consume_in_thread() reactor.wait() heat-2014.1.5/heat/openstack/common/rpc/__init__.py0000664000567000056700000002451212540642614023132 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # Copyright 2011 Red Hat, Inc. # # 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. """ A remote procedure call (rpc) abstraction. For some wrappers that add message versioning to rpc, see: rpc.dispatcher rpc.proxy """ from oslo.config import cfg from heat.openstack.common import importutils from heat.openstack.common import log as logging LOG = logging.getLogger(__name__) rpc_opts = [ cfg.StrOpt('rpc_backend', default='%s.impl_kombu' % __package__, help="The messaging module to use, defaults to kombu."), cfg.IntOpt('rpc_thread_pool_size', default=64, help='Size of RPC thread pool'), cfg.IntOpt('rpc_conn_pool_size', default=30, help='Size of RPC connection pool'), cfg.IntOpt('rpc_response_timeout', default=60, help='Seconds to wait for a response from call or multicall'), cfg.IntOpt('rpc_cast_timeout', default=30, help='Seconds to wait before a cast expires (TTL). ' 'Only supported by impl_zmq.'), cfg.ListOpt('allowed_rpc_exception_modules', default=['nova.exception', 'cinder.exception', 'exceptions', ], help='Modules of exceptions that are permitted to be recreated' ' upon receiving exception data from an rpc call.'), cfg.BoolOpt('fake_rabbit', default=False, help='If passed, use a fake RabbitMQ provider'), cfg.StrOpt('control_exchange', default='openstack', help='AMQP exchange to connect to if using RabbitMQ or Qpid'), ] CONF = cfg.CONF CONF.register_opts(rpc_opts) def set_defaults(control_exchange): cfg.set_defaults(rpc_opts, control_exchange=control_exchange) def create_connection(new=True): """Create a connection to the message bus used for rpc. For some example usage of creating a connection and some consumers on that connection, see nova.service. :param new: Whether or not to create a new connection. A new connection will be created by default. If new is False, the implementation is free to return an existing connection from a pool. :returns: An instance of openstack.common.rpc.common.Connection """ return _get_impl().create_connection(CONF, new=new) def call(context, topic, msg, timeout=None): """Invoke a remote method that returns something. :param context: Information that identifies the user that has made this request. :param topic: The topic to send the rpc message to. This correlates to the topic argument of openstack.common.rpc.common.Connection.create_consumer() and only applies when the consumer was created with fanout=False. :param msg: This is a dict in the form { "method" : "method_to_invoke", "args" : dict_of_kwargs } :param timeout: int, number of seconds to use for a response timeout. If set, this overrides the rpc_response_timeout option. :returns: A dict from the remote method. :raises: openstack.common.rpc.common.Timeout if a complete response is not received before the timeout is reached. """ return _get_impl().call(CONF, context, topic, msg, timeout) def cast(context, topic, msg): """Invoke a remote method that does not return anything. :param context: Information that identifies the user that has made this request. :param topic: The topic to send the rpc message to. This correlates to the topic argument of openstack.common.rpc.common.Connection.create_consumer() and only applies when the consumer was created with fanout=False. :param msg: This is a dict in the form { "method" : "method_to_invoke", "args" : dict_of_kwargs } :returns: None """ return _get_impl().cast(CONF, context, topic, msg) def fanout_cast(context, topic, msg): """Broadcast a remote method invocation with no return. This method will get invoked on all consumers that were set up with this topic name and fanout=True. :param context: Information that identifies the user that has made this request. :param topic: The topic to send the rpc message to. This correlates to the topic argument of openstack.common.rpc.common.Connection.create_consumer() and only applies when the consumer was created with fanout=True. :param msg: This is a dict in the form { "method" : "method_to_invoke", "args" : dict_of_kwargs } :returns: None """ return _get_impl().fanout_cast(CONF, context, topic, msg) def multicall(context, topic, msg, timeout=None): """Invoke a remote method and get back an iterator. In this case, the remote method will be returning multiple values in separate messages, so the return values can be processed as the come in via an iterator. :param context: Information that identifies the user that has made this request. :param topic: The topic to send the rpc message to. This correlates to the topic argument of openstack.common.rpc.common.Connection.create_consumer() and only applies when the consumer was created with fanout=False. :param msg: This is a dict in the form { "method" : "method_to_invoke", "args" : dict_of_kwargs } :param timeout: int, number of seconds to use for a response timeout. If set, this overrides the rpc_response_timeout option. :returns: An iterator. The iterator will yield a tuple (N, X) where N is an index that starts at 0 and increases by one for each value returned and X is the Nth value that was returned by the remote method. :raises: openstack.common.rpc.common.Timeout if a complete response is not received before the timeout is reached. """ return _get_impl().multicall(CONF, context, topic, msg, timeout) def notify(context, topic, msg, envelope=False): """Send notification event. :param context: Information that identifies the user that has made this request. :param topic: The topic to send the notification to. :param msg: This is a dict of content of event. :param envelope: Set to True to enable message envelope for notifications. :returns: None """ return _get_impl().notify(cfg.CONF, context, topic, msg, envelope) def cleanup(): """Clean up resources in use by implementation. Clean up any resources that have been allocated by the RPC implementation. This is typically open connections to a messaging service. This function would get called before an application using this API exits to allow connections to get torn down cleanly. :returns: None """ return _get_impl().cleanup() def cast_to_server(context, server_params, topic, msg): """Invoke a remote method that does not return anything. :param context: Information that identifies the user that has made this request. :param server_params: Connection information :param topic: The topic to send the notification to. :param msg: This is a dict in the form { "method" : "method_to_invoke", "args" : dict_of_kwargs } :returns: None """ return _get_impl().cast_to_server(CONF, context, server_params, topic, msg) def fanout_cast_to_server(context, server_params, topic, msg): """Broadcast to a remote method invocation with no return. :param context: Information that identifies the user that has made this request. :param server_params: Connection information :param topic: The topic to send the notification to. :param msg: This is a dict in the form { "method" : "method_to_invoke", "args" : dict_of_kwargs } :returns: None """ return _get_impl().fanout_cast_to_server(CONF, context, server_params, topic, msg) def queue_get_for(context, topic, host): """Get a queue name for a given topic + host. This function only works if this naming convention is followed on the consumer side, as well. For example, in nova, every instance of the nova-foo service calls create_consumer() for two topics: foo foo. Messages sent to the 'foo' topic are distributed to exactly one instance of the nova-foo service. The services are chosen in a round-robin fashion. Messages sent to the 'foo.' topic are sent to the nova-foo service on . """ return '%s.%s' % (topic, host) if host else topic _RPCIMPL = None def _get_impl(): """Delay import of rpc_backend until configuration is loaded.""" global _RPCIMPL if _RPCIMPL is None: try: _RPCIMPL = importutils.import_module(CONF.rpc_backend) except ImportError: # For backwards compatibility with older nova config. impl = CONF.rpc_backend.replace('nova.rpc', 'nova.openstack.common.rpc') _RPCIMPL = importutils.import_module(impl) return _RPCIMPL heat-2014.1.5/heat/openstack/common/rpc/common.py0000664000567000056700000004417612540642614022673 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # Copyright 2011 Red Hat, Inc. # # 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. import copy import sys import traceback from oslo.config import cfg import six from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import jsonutils from heat.openstack.common import local from heat.openstack.common import log as logging from heat.openstack.common import versionutils CONF = cfg.CONF LOG = logging.getLogger(__name__) _RPC_ENVELOPE_VERSION = '2.0' '''RPC Envelope Version. This version number applies to the top level structure of messages sent out. It does *not* apply to the message payload, which must be versioned independently. For example, when using rpc APIs, a version number is applied for changes to the API being exposed over rpc. This version number is handled in the rpc proxy and dispatcher modules. This version number applies to the message envelope that is used in the serialization done inside the rpc layer. See serialize_msg() and deserialize_msg(). The current message format (version 2.0) is very simple. It is:: { 'oslo.version': , 'oslo.message': } Message format version '1.0' is just considered to be the messages we sent without a message envelope. So, the current message envelope just includes the envelope version. It may eventually contain additional information, such as a signature for the message payload. We will JSON encode the application message payload. The message envelope, which includes the JSON encoded application message body, will be passed down to the messaging libraries as a dict. ''' _VERSION_KEY = 'oslo.version' _MESSAGE_KEY = 'oslo.message' _REMOTE_POSTFIX = '_Remote' class RPCException(Exception): msg_fmt = _("An unknown RPC related exception occurred.") def __init__(self, message=None, **kwargs): self.kwargs = kwargs if not message: try: message = self.msg_fmt % kwargs except Exception: # kwargs doesn't match a variable in the message # log the issue and the kwargs LOG.exception(_('Exception in string format operation')) for name, value in six.iteritems(kwargs): LOG.error("%s: %s" % (name, value)) # at least get the core message out if something happened message = self.msg_fmt super(RPCException, self).__init__(message) class RemoteError(RPCException): """Signifies that a remote class has raised an exception. Contains a string representation of the type of the original exception, the value of the original exception, and the traceback. These are sent to the parent as a joined string so printing the exception contains all of the relevant info. """ msg_fmt = _("Remote error: %(exc_type)s %(value)s\n%(traceback)s.") def __init__(self, exc_type=None, value=None, traceback=None): self.exc_type = exc_type self.value = value self.traceback = traceback super(RemoteError, self).__init__(exc_type=exc_type, value=value, traceback=traceback) class Timeout(RPCException): """Signifies that a timeout has occurred. This exception is raised if the rpc_response_timeout is reached while waiting for a response from the remote side. """ msg_fmt = _('Timeout while waiting on RPC response - ' 'topic: "%(topic)s", RPC method: "%(method)s" ' 'info: "%(info)s"') def __init__(self, info=None, topic=None, method=None): """Initiates Timeout object. :param info: Extra info to convey to the user :param topic: The topic that the rpc call was sent to :param rpc_method_name: The name of the rpc method being called """ self.info = info self.topic = topic self.method = method super(Timeout, self).__init__( None, info=info or _(''), topic=topic or _(''), method=method or _('')) class DuplicateMessageError(RPCException): msg_fmt = _("Found duplicate message(%(msg_id)s). Skipping it.") class InvalidRPCConnectionReuse(RPCException): msg_fmt = _("Invalid reuse of an RPC connection.") class UnsupportedRpcVersion(RPCException): msg_fmt = _("Specified RPC version, %(version)s, not supported by " "this endpoint.") class UnsupportedRpcEnvelopeVersion(RPCException): msg_fmt = _("Specified RPC envelope version, %(version)s, " "not supported by this endpoint.") class RpcVersionCapError(RPCException): msg_fmt = _("Specified RPC version cap, %(version_cap)s, is too low") class Connection(object): """A connection, returned by rpc.create_connection(). This class represents a connection to the message bus used for rpc. An instance of this class should never be created by users of the rpc API. Use rpc.create_connection() instead. """ def close(self): """Close the connection. This method must be called when the connection will no longer be used. It will ensure that any resources associated with the connection, such as a network connection, and cleaned up. """ raise NotImplementedError() def create_consumer(self, topic, proxy, fanout=False): """Create a consumer on this connection. A consumer is associated with a message queue on the backend message bus. The consumer will read messages from the queue, unpack them, and dispatch them to the proxy object. The contents of the message pulled off of the queue will determine which method gets called on the proxy object. :param topic: This is a name associated with what to consume from. Multiple instances of a service may consume from the same topic. For example, all instances of nova-compute consume from a queue called "compute". In that case, the messages will get distributed amongst the consumers in a round-robin fashion if fanout=False. If fanout=True, every consumer associated with this topic will get a copy of every message. :param proxy: The object that will handle all incoming messages. :param fanout: Whether or not this is a fanout topic. See the documentation for the topic parameter for some additional comments on this. """ raise NotImplementedError() def create_worker(self, topic, proxy, pool_name): """Create a worker on this connection. A worker is like a regular consumer of messages directed to a topic, except that it is part of a set of such consumers (the "pool") which may run in parallel. Every pool of workers will receive a given message, but only one worker in the pool will be asked to process it. Load is distributed across the members of the pool in round-robin fashion. :param topic: This is a name associated with what to consume from. Multiple instances of a service may consume from the same topic. :param proxy: The object that will handle all incoming messages. :param pool_name: String containing the name of the pool of workers """ raise NotImplementedError() def join_consumer_pool(self, callback, pool_name, topic, exchange_name): """Register as a member of a group of consumers. Uses given topic from the specified exchange. Exactly one member of a given pool will receive each message. A message will be delivered to multiple pools, if more than one is created. :param callback: Callable to be invoked for each message. :type callback: callable accepting one argument :param pool_name: The name of the consumer pool. :type pool_name: str :param topic: The routing topic for desired messages. :type topic: str :param exchange_name: The name of the message exchange where the client should attach. Defaults to the configured exchange. :type exchange_name: str """ raise NotImplementedError() def consume_in_thread(self): """Spawn a thread to handle incoming messages. Spawn a thread that will be responsible for handling all incoming messages for consumers that were set up on this connection. Message dispatching inside of this is expected to be implemented in a non-blocking manner. An example implementation would be having this thread pull messages in for all of the consumers, but utilize a thread pool for dispatching the messages to the proxy objects. """ raise NotImplementedError() def _safe_log(log_func, msg, msg_data): """Sanitizes the msg_data field before logging.""" SANITIZE = ['_context_auth_token', 'auth_token', 'new_pass'] def _fix_passwords(d): """Sanitizes the password fields in the dictionary.""" for k in six.iterkeys(d): if k.lower().find('password') != -1: d[k] = '' elif k.lower() in SANITIZE: d[k] = '' elif isinstance(d[k], list): for e in d[k]: if isinstance(e, dict): _fix_passwords(e) elif isinstance(d[k], dict): _fix_passwords(d[k]) return d return log_func(msg, _fix_passwords(copy.deepcopy(msg_data))) def serialize_remote_exception(failure_info, log_failure=True): """Prepares exception data to be sent over rpc. Failure_info should be a sys.exc_info() tuple. """ tb = traceback.format_exception(*failure_info) failure = failure_info[1] if log_failure: LOG.error(_("Returning exception %s to caller"), six.text_type(failure)) LOG.error(tb) kwargs = {} if hasattr(failure, 'kwargs'): kwargs = failure.kwargs # NOTE(matiu): With cells, it's possible to re-raise remote, remote # exceptions. Lets turn it back into the original exception type. cls_name = str(failure.__class__.__name__) mod_name = str(failure.__class__.__module__) if (cls_name.endswith(_REMOTE_POSTFIX) and mod_name.endswith(_REMOTE_POSTFIX)): cls_name = cls_name[:-len(_REMOTE_POSTFIX)] mod_name = mod_name[:-len(_REMOTE_POSTFIX)] data = { 'class': cls_name, 'module': mod_name, 'message': six.text_type(failure), 'tb': tb, 'args': failure.args, 'kwargs': kwargs } json_data = jsonutils.dumps(data) return json_data def deserialize_remote_exception(conf, data): failure = jsonutils.loads(str(data)) trace = failure.get('tb', []) message = failure.get('message', "") + "\n" + "\n".join(trace) name = failure.get('class') module = failure.get('module') # NOTE(ameade): We DO NOT want to allow just any module to be imported, in # order to prevent arbitrary code execution. if module not in conf.allowed_rpc_exception_modules: return RemoteError(name, failure.get('message'), trace) try: mod = importutils.import_module(module) klass = getattr(mod, name) if not issubclass(klass, Exception): raise TypeError("Can only deserialize Exceptions") failure = klass(*failure.get('args', []), **failure.get('kwargs', {})) except (AttributeError, TypeError, ImportError): return RemoteError(name, failure.get('message'), trace) ex_type = type(failure) str_override = lambda self: message new_ex_type = type(ex_type.__name__ + _REMOTE_POSTFIX, (ex_type,), {'__str__': str_override, '__unicode__': str_override}) new_ex_type.__module__ = '%s%s' % (module, _REMOTE_POSTFIX) try: # NOTE(ameade): Dynamically create a new exception type and swap it in # as the new type for the exception. This only works on user defined # Exceptions and not core python exceptions. This is important because # we cannot necessarily change an exception message so we must override # the __str__ method. failure.__class__ = new_ex_type except TypeError: # NOTE(ameade): If a core exception then just add the traceback to the # first exception argument. failure.args = (message,) + failure.args[1:] return failure class CommonRpcContext(object): def __init__(self, **kwargs): self.values = kwargs def __getattr__(self, key): try: return self.values[key] except KeyError: raise AttributeError(key) def to_dict(self): return copy.deepcopy(self.values) @classmethod def from_dict(cls, values): return cls(**values) def deepcopy(self): return self.from_dict(self.to_dict()) def update_store(self): local.store.context = self def elevated(self, read_deleted=None, overwrite=False): """Return a version of this context with admin flag set.""" # TODO(russellb) This method is a bit of a nova-ism. It makes # some assumptions about the data in the request context sent # across rpc, while the rest of this class does not. We could get # rid of this if we changed the nova code that uses this to # convert the RpcContext back to its native RequestContext doing # something like nova.context.RequestContext.from_dict(ctxt.to_dict()) context = self.deepcopy() context.values['is_admin'] = True context.values.setdefault('roles', []) if 'admin' not in context.values['roles']: context.values['roles'].append('admin') if read_deleted is not None: context.values['read_deleted'] = read_deleted return context class ClientException(Exception): """Encapsulates actual exception expected to be hit by a RPC proxy object. Merely instantiating it records the current exception information, which will be passed back to the RPC client without exceptional logging. """ def __init__(self): self._exc_info = sys.exc_info() def catch_client_exception(exceptions, func, *args, **kwargs): try: return func(*args, **kwargs) except Exception as e: if type(e) in exceptions: raise ClientException() else: raise def client_exceptions(*exceptions): """Decorator for manager methods that raise expected exceptions. Marking a Manager method with this decorator allows the declaration of expected exceptions that the RPC layer should not consider fatal, and not log as if they were generated in a real error scenario. Note that this will cause listed exceptions to be wrapped in a ClientException, which is used internally by the RPC layer. """ def outer(func): def inner(*args, **kwargs): return catch_client_exception(exceptions, func, *args, **kwargs) return inner return outer # TODO(sirp): we should deprecate this in favor of # using `versionutils.is_compatible` directly def version_is_compatible(imp_version, version): """Determine whether versions are compatible. :param imp_version: The version implemented :param version: The version requested by an incoming message. """ return versionutils.is_compatible(version, imp_version) def serialize_msg(raw_msg): # NOTE(russellb) See the docstring for _RPC_ENVELOPE_VERSION for more # information about this format. msg = {_VERSION_KEY: _RPC_ENVELOPE_VERSION, _MESSAGE_KEY: jsonutils.dumps(raw_msg)} return msg def deserialize_msg(msg): # NOTE(russellb): Hang on to your hats, this road is about to # get a little bumpy. # # Robustness Principle: # "Be strict in what you send, liberal in what you accept." # # At this point we have to do a bit of guessing about what it # is we just received. Here is the set of possibilities: # # 1) We received a dict. This could be 2 things: # # a) Inspect it to see if it looks like a standard message envelope. # If so, great! # # b) If it doesn't look like a standard message envelope, it could either # be a notification, or a message from before we added a message # envelope (referred to as version 1.0). # Just return the message as-is. # # 2) It's any other non-dict type. Just return it and hope for the best. # This case covers return values from rpc.call() from before message # envelopes were used. (messages to call a method were always a dict) if not isinstance(msg, dict): # See #2 above. return msg base_envelope_keys = (_VERSION_KEY, _MESSAGE_KEY) if not all(map(lambda key: key in msg, base_envelope_keys)): # See #1.b above. return msg # At this point we think we have the message envelope # format we were expecting. (#1.a above) if not version_is_compatible(_RPC_ENVELOPE_VERSION, msg[_VERSION_KEY]): raise UnsupportedRpcEnvelopeVersion(version=msg[_VERSION_KEY]) raw_msg = jsonutils.loads(msg[_MESSAGE_KEY]) return raw_msg heat-2014.1.5/heat/openstack/common/rpc/impl_kombu.py0000664000567000056700000010005512540642614023526 0ustar jenkinsjenkins00000000000000# Copyright 2011 OpenStack Foundation # # 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. import functools import itertools import socket import ssl import time import uuid import eventlet import greenlet import kombu import kombu.connection import kombu.entity import kombu.messaging from oslo.config import cfg import six from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import network_utils from heat.openstack.common.rpc import amqp as rpc_amqp from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common import sslutils kombu_opts = [ cfg.StrOpt('kombu_ssl_version', default='', help='SSL version to use (valid only if SSL enabled). ' 'valid values are TLSv1, SSLv23 and SSLv3. SSLv2 may ' 'be available on some distributions' ), cfg.StrOpt('kombu_ssl_keyfile', default='', help='SSL key file (valid only if SSL enabled)'), cfg.StrOpt('kombu_ssl_certfile', default='', help='SSL cert file (valid only if SSL enabled)'), cfg.StrOpt('kombu_ssl_ca_certs', default='', help=('SSL certification authority file ' '(valid only if SSL enabled)')), cfg.StrOpt('rabbit_host', default='localhost', help='The RabbitMQ broker address where a single node is used'), cfg.IntOpt('rabbit_port', default=5672, help='The RabbitMQ broker port where a single node is used'), cfg.ListOpt('rabbit_hosts', default=['$rabbit_host:$rabbit_port'], help='RabbitMQ HA cluster host:port pairs'), cfg.BoolOpt('rabbit_use_ssl', default=False, help='connect over SSL for RabbitMQ'), cfg.StrOpt('rabbit_userid', default='guest', help='the RabbitMQ userid'), cfg.StrOpt('rabbit_password', default='guest', help='the RabbitMQ password', secret=True), cfg.StrOpt('rabbit_virtual_host', default='/', help='the RabbitMQ virtual host'), cfg.IntOpt('rabbit_retry_interval', default=1, help='how frequently to retry connecting with RabbitMQ'), cfg.IntOpt('rabbit_retry_backoff', default=2, help='how long to backoff for between retries when connecting ' 'to RabbitMQ'), cfg.IntOpt('rabbit_max_retries', default=0, help='maximum retries with trying to connect to RabbitMQ ' '(the default of 0 implies an infinite retry count)'), cfg.BoolOpt('rabbit_ha_queues', default=False, help='use H/A queues in RabbitMQ (x-ha-policy: all).' 'You need to wipe RabbitMQ database when ' 'changing this option.'), ] cfg.CONF.register_opts(kombu_opts) LOG = rpc_common.LOG def _get_queue_arguments(conf): """Construct the arguments for declaring a queue. If the rabbit_ha_queues option is set, we declare a mirrored queue as described here: http://www.rabbitmq.com/ha.html Setting x-ha-policy to all means that the queue will be mirrored to all nodes in the cluster. """ return {'x-ha-policy': 'all'} if conf.rabbit_ha_queues else {} class ConsumerBase(object): """Consumer base class.""" def __init__(self, channel, callback, tag, **kwargs): """Declare a queue on an amqp channel. 'channel' is the amqp channel to use 'callback' is the callback to call when messages are received 'tag' is a unique ID for the consumer on the channel queue name, exchange name, and other kombu options are passed in here as a dictionary. """ self.callback = callback self.tag = str(tag) self.kwargs = kwargs self.queue = None self.ack_on_error = kwargs.get('ack_on_error', True) self.reconnect(channel) def reconnect(self, channel): """Re-declare the queue after a rabbit reconnect.""" self.channel = channel self.kwargs['channel'] = channel self.queue = kombu.entity.Queue(**self.kwargs) self.queue.declare() def _callback_handler(self, message, callback): """Call callback with deserialized message. Messages that are processed without exception are ack'ed. If the message processing generates an exception, it will be ack'ed if ack_on_error=True. Otherwise it will be .requeue()'ed. """ try: msg = rpc_common.deserialize_msg(message.payload) callback(msg) except Exception: if self.ack_on_error: LOG.exception(_("Failed to process message" " ... skipping it.")) message.ack() else: LOG.exception(_("Failed to process message" " ... will requeue.")) message.requeue() else: message.ack() def consume(self, *args, **kwargs): """Actually declare the consumer on the amqp channel. This will start the flow of messages from the queue. Using the Connection.iterconsume() iterator will process the messages, calling the appropriate callback. If a callback is specified in kwargs, use that. Otherwise, use the callback passed during __init__() If kwargs['nowait'] is True, then this call will block until a message is read. """ options = {'consumer_tag': self.tag} options['nowait'] = kwargs.get('nowait', False) callback = kwargs.get('callback', self.callback) if not callback: raise ValueError("No callback defined") def _callback(raw_message): message = self.channel.message_to_python(raw_message) self._callback_handler(message, callback) self.queue.consume(*args, callback=_callback, **options) def cancel(self): """Cancel the consuming from the queue, if it has started.""" try: self.queue.cancel(self.tag) except KeyError as e: # NOTE(comstud): Kludge to get around a amqplib bug if str(e) != "u'%s'" % self.tag: raise self.queue = None class DirectConsumer(ConsumerBase): """Queue/consumer class for 'direct'.""" def __init__(self, conf, channel, msg_id, callback, tag, **kwargs): """Init a 'direct' queue. 'channel' is the amqp channel to use 'msg_id' is the msg_id to listen on 'callback' is the callback to call when messages are received 'tag' is a unique ID for the consumer on the channel Other kombu options may be passed """ # Default options options = {'durable': False, 'queue_arguments': _get_queue_arguments(conf), 'auto_delete': True, 'exclusive': False} options.update(kwargs) exchange = kombu.entity.Exchange(name=msg_id, type='direct', durable=options['durable'], auto_delete=options['auto_delete']) super(DirectConsumer, self).__init__(channel, callback, tag, name=msg_id, exchange=exchange, routing_key=msg_id, **options) class TopicConsumer(ConsumerBase): """Consumer class for 'topic'.""" def __init__(self, conf, channel, topic, callback, tag, name=None, exchange_name=None, **kwargs): """Init a 'topic' queue. :param channel: the amqp channel to use :param topic: the topic to listen on :paramtype topic: str :param callback: the callback to call when messages are received :param tag: a unique ID for the consumer on the channel :param name: optional queue name, defaults to topic :paramtype name: str Other kombu options may be passed as keyword arguments """ # Default options options = {'durable': conf.amqp_durable_queues, 'queue_arguments': _get_queue_arguments(conf), 'auto_delete': conf.amqp_auto_delete, 'exclusive': False} options.update(kwargs) exchange_name = exchange_name or rpc_amqp.get_control_exchange(conf) exchange = kombu.entity.Exchange(name=exchange_name, type='topic', durable=options['durable'], auto_delete=options['auto_delete']) super(TopicConsumer, self).__init__(channel, callback, tag, name=name or topic, exchange=exchange, routing_key=topic, **options) class FanoutConsumer(ConsumerBase): """Consumer class for 'fanout'.""" def __init__(self, conf, channel, topic, callback, tag, **kwargs): """Init a 'fanout' queue. 'channel' is the amqp channel to use 'topic' is the topic to listen on 'callback' is the callback to call when messages are received 'tag' is a unique ID for the consumer on the channel Other kombu options may be passed """ unique = uuid.uuid4().hex exchange_name = '%s_fanout' % topic queue_name = '%s_fanout_%s' % (topic, unique) # Default options options = {'durable': False, 'queue_arguments': _get_queue_arguments(conf), 'auto_delete': True, 'exclusive': False} options.update(kwargs) exchange = kombu.entity.Exchange(name=exchange_name, type='fanout', durable=options['durable'], auto_delete=options['auto_delete']) super(FanoutConsumer, self).__init__(channel, callback, tag, name=queue_name, exchange=exchange, routing_key=topic, **options) class Publisher(object): """Base Publisher class.""" def __init__(self, channel, exchange_name, routing_key, **kwargs): """Init the Publisher class with the exchange_name, routing_key, and other options """ self.exchange_name = exchange_name self.routing_key = routing_key self.kwargs = kwargs self.reconnect(channel) def reconnect(self, channel): """Re-establish the Producer after a rabbit reconnection.""" self.exchange = kombu.entity.Exchange(name=self.exchange_name, **self.kwargs) self.producer = kombu.messaging.Producer(exchange=self.exchange, channel=channel, routing_key=self.routing_key) def send(self, msg, timeout=None): """Send a message.""" if timeout: # # AMQP TTL is in milliseconds when set in the header. # self.producer.publish(msg, headers={'ttl': (timeout * 1000)}) else: self.producer.publish(msg) class DirectPublisher(Publisher): """Publisher class for 'direct'.""" def __init__(self, conf, channel, msg_id, **kwargs): """init a 'direct' publisher. Kombu options may be passed as keyword args to override defaults """ options = {'durable': False, 'auto_delete': True, 'exclusive': False} options.update(kwargs) super(DirectPublisher, self).__init__(channel, msg_id, msg_id, type='direct', **options) class TopicPublisher(Publisher): """Publisher class for 'topic'.""" def __init__(self, conf, channel, topic, **kwargs): """init a 'topic' publisher. Kombu options may be passed as keyword args to override defaults """ options = {'durable': conf.amqp_durable_queues, 'auto_delete': conf.amqp_auto_delete, 'exclusive': False} options.update(kwargs) exchange_name = rpc_amqp.get_control_exchange(conf) super(TopicPublisher, self).__init__(channel, exchange_name, topic, type='topic', **options) class FanoutPublisher(Publisher): """Publisher class for 'fanout'.""" def __init__(self, conf, channel, topic, **kwargs): """init a 'fanout' publisher. Kombu options may be passed as keyword args to override defaults """ options = {'durable': False, 'auto_delete': True, 'exclusive': False} options.update(kwargs) super(FanoutPublisher, self).__init__(channel, '%s_fanout' % topic, None, type='fanout', **options) class NotifyPublisher(TopicPublisher): """Publisher class for 'notify'.""" def __init__(self, conf, channel, topic, **kwargs): self.durable = kwargs.pop('durable', conf.amqp_durable_queues) self.queue_arguments = _get_queue_arguments(conf) super(NotifyPublisher, self).__init__(conf, channel, topic, **kwargs) def reconnect(self, channel): super(NotifyPublisher, self).reconnect(channel) # NOTE(jerdfelt): Normally the consumer would create the queue, but # we do this to ensure that messages don't get dropped if the # consumer is started after we do queue = kombu.entity.Queue(channel=channel, exchange=self.exchange, durable=self.durable, name=self.routing_key, routing_key=self.routing_key, queue_arguments=self.queue_arguments) queue.declare() class Connection(object): """Connection object.""" pool = None def __init__(self, conf, server_params=None): self.consumers = [] self.consumer_thread = None self.proxy_callbacks = [] self.conf = conf self.max_retries = self.conf.rabbit_max_retries # Try forever? if self.max_retries <= 0: self.max_retries = None self.interval_start = self.conf.rabbit_retry_interval self.interval_stepping = self.conf.rabbit_retry_backoff # max retry-interval = 30 seconds self.interval_max = 30 self.memory_transport = False if server_params is None: server_params = {} # Keys to translate from server_params to kombu params server_params_to_kombu_params = {'username': 'userid'} ssl_params = self._fetch_ssl_params() params_list = [] for adr in self.conf.rabbit_hosts: hostname, port = network_utils.parse_host_port( adr, default_port=self.conf.rabbit_port) params = { 'hostname': hostname, 'port': port, 'userid': self.conf.rabbit_userid, 'password': self.conf.rabbit_password, 'virtual_host': self.conf.rabbit_virtual_host, } for sp_key, value in six.iteritems(server_params): p_key = server_params_to_kombu_params.get(sp_key, sp_key) params[p_key] = value if self.conf.fake_rabbit: params['transport'] = 'memory' if self.conf.rabbit_use_ssl: params['ssl'] = ssl_params params_list.append(params) self.params_list = params_list brokers_count = len(self.params_list) self.next_broker_indices = itertools.cycle(range(brokers_count)) self.memory_transport = self.conf.fake_rabbit self.connection = None self.reconnect() def _fetch_ssl_params(self): """Handles fetching what ssl params should be used for the connection (if any). """ ssl_params = dict() # http://docs.python.org/library/ssl.html - ssl.wrap_socket if self.conf.kombu_ssl_version: ssl_params['ssl_version'] = sslutils.validate_ssl_version( self.conf.kombu_ssl_version) if self.conf.kombu_ssl_keyfile: ssl_params['keyfile'] = self.conf.kombu_ssl_keyfile if self.conf.kombu_ssl_certfile: ssl_params['certfile'] = self.conf.kombu_ssl_certfile if self.conf.kombu_ssl_ca_certs: ssl_params['ca_certs'] = self.conf.kombu_ssl_ca_certs # We might want to allow variations in the # future with this? ssl_params['cert_reqs'] = ssl.CERT_REQUIRED # Return the extended behavior or just have the default behavior return ssl_params or True def _connect(self, params): """Connect to rabbit. Re-establish any queues that may have been declared before if we are reconnecting. Exceptions should be handled by the caller. """ if self.connection: LOG.info(_("Reconnecting to AMQP server on " "%(hostname)s:%(port)d") % params) try: self.connection.release() except self.connection_errors: pass # Setting this in case the next statement fails, though # it shouldn't be doing any network operations, yet. self.connection = None self.connection = kombu.connection.BrokerConnection(**params) self.connection_errors = self.connection.connection_errors if self.memory_transport: # Kludge to speed up tests. self.connection.transport.polling_interval = 0.0 self.consumer_num = itertools.count(1) self.connection.connect() self.channel = self.connection.channel() # work around 'memory' transport bug in 1.1.3 if self.memory_transport: self.channel._new_queue('ae.undeliver') for consumer in self.consumers: consumer.reconnect(self.channel) LOG.info(_('Connected to AMQP server on %(hostname)s:%(port)d') % params) def reconnect(self): """Handles reconnecting and re-establishing queues. Will retry up to self.max_retries number of times. self.max_retries = 0 means to retry forever. Sleep between tries, starting at self.interval_start seconds, backing off self.interval_stepping number of seconds each attempt. """ attempt = 0 while True: params = self.params_list[next(self.next_broker_indices)] attempt += 1 try: self._connect(params) return except (IOError, self.connection_errors) as e: pass except Exception as e: # NOTE(comstud): Unfortunately it's possible for amqplib # to return an error not covered by its transport # connection_errors in the case of a timeout waiting for # a protocol response. (See paste link in LP888621) # So, we check all exceptions for 'timeout' in them # and try to reconnect in this case. if 'timeout' not in str(e): raise log_info = {} log_info['err_str'] = str(e) log_info['max_retries'] = self.max_retries log_info.update(params) if self.max_retries and attempt == self.max_retries: msg = _('Unable to connect to AMQP server on ' '%(hostname)s:%(port)d after %(max_retries)d ' 'tries: %(err_str)s') % log_info LOG.error(msg) raise rpc_common.RPCException(msg) if attempt == 1: sleep_time = self.interval_start or 1 elif attempt > 1: sleep_time += self.interval_stepping if self.interval_max: sleep_time = min(sleep_time, self.interval_max) log_info['sleep_time'] = sleep_time LOG.error(_('AMQP server on %(hostname)s:%(port)d is ' 'unreachable: %(err_str)s. Trying again in ' '%(sleep_time)d seconds.') % log_info) time.sleep(sleep_time) def ensure(self, error_callback, method, *args, **kwargs): while True: try: return method(*args, **kwargs) except (self.connection_errors, socket.timeout, IOError) as e: if error_callback: error_callback(e) except Exception as e: # NOTE(comstud): Unfortunately it's possible for amqplib # to return an error not covered by its transport # connection_errors in the case of a timeout waiting for # a protocol response. (See paste link in LP888621) # So, we check all exceptions for 'timeout' in them # and try to reconnect in this case. if 'timeout' not in str(e): raise if error_callback: error_callback(e) self.reconnect() def get_channel(self): """Convenience call for bin/clear_rabbit_queues.""" return self.channel def close(self): """Close/release this connection.""" self.cancel_consumer_thread() self.wait_on_proxy_callbacks() self.connection.release() self.connection = None def reset(self): """Reset a connection so it can be used again.""" self.cancel_consumer_thread() self.wait_on_proxy_callbacks() self.channel.close() self.channel = self.connection.channel() # work around 'memory' transport bug in 1.1.3 if self.memory_transport: self.channel._new_queue('ae.undeliver') self.consumers = [] def declare_consumer(self, consumer_cls, topic, callback): """Create a Consumer using the class that was passed in and add it to our list of consumers """ def _connect_error(exc): log_info = {'topic': topic, 'err_str': str(exc)} LOG.error(_("Failed to declare consumer for topic '%(topic)s': " "%(err_str)s") % log_info) def _declare_consumer(): consumer = consumer_cls(self.conf, self.channel, topic, callback, six.next(self.consumer_num)) self.consumers.append(consumer) return consumer return self.ensure(_connect_error, _declare_consumer) def iterconsume(self, limit=None, timeout=None): """Return an iterator that will consume from all queues/consumers.""" info = {'do_consume': True} def _error_callback(exc): if isinstance(exc, socket.timeout): LOG.debug(_('Timed out waiting for RPC response: %s') % str(exc)) raise rpc_common.Timeout() else: LOG.exception(_('Failed to consume message from queue: %s') % str(exc)) info['do_consume'] = True def _consume(): if info['do_consume']: queues_head = self.consumers[:-1] # not fanout. queues_tail = self.consumers[-1] # fanout for queue in queues_head: queue.consume(nowait=True) queues_tail.consume(nowait=False) info['do_consume'] = False return self.connection.drain_events(timeout=timeout) for iteration in itertools.count(0): if limit and iteration >= limit: raise StopIteration yield self.ensure(_error_callback, _consume) def cancel_consumer_thread(self): """Cancel a consumer thread.""" if self.consumer_thread is not None: self.consumer_thread.kill() try: self.consumer_thread.wait() except greenlet.GreenletExit: pass self.consumer_thread = None def wait_on_proxy_callbacks(self): """Wait for all proxy callback threads to exit.""" for proxy_cb in self.proxy_callbacks: proxy_cb.wait() def publisher_send(self, cls, topic, msg, timeout=None, **kwargs): """Send to a publisher based on the publisher class.""" def _error_callback(exc): log_info = {'topic': topic, 'err_str': str(exc)} LOG.exception(_("Failed to publish message to topic " "'%(topic)s': %(err_str)s") % log_info) def _publish(): publisher = cls(self.conf, self.channel, topic, **kwargs) publisher.send(msg, timeout) self.ensure(_error_callback, _publish) def declare_direct_consumer(self, topic, callback): """Create a 'direct' queue. In nova's use, this is generally a msg_id queue used for responses for call/multicall """ self.declare_consumer(DirectConsumer, topic, callback) def declare_topic_consumer(self, topic, callback=None, queue_name=None, exchange_name=None, ack_on_error=True): """Create a 'topic' consumer.""" self.declare_consumer(functools.partial(TopicConsumer, name=queue_name, exchange_name=exchange_name, ack_on_error=ack_on_error, ), topic, callback) def declare_fanout_consumer(self, topic, callback): """Create a 'fanout' consumer.""" self.declare_consumer(FanoutConsumer, topic, callback) def direct_send(self, msg_id, msg): """Send a 'direct' message.""" self.publisher_send(DirectPublisher, msg_id, msg) def topic_send(self, topic, msg, timeout=None): """Send a 'topic' message.""" self.publisher_send(TopicPublisher, topic, msg, timeout) def fanout_send(self, topic, msg): """Send a 'fanout' message.""" self.publisher_send(FanoutPublisher, topic, msg) def notify_send(self, topic, msg, **kwargs): """Send a notify message on a topic.""" self.publisher_send(NotifyPublisher, topic, msg, None, **kwargs) def consume(self, limit=None): """Consume from all queues/consumers.""" it = self.iterconsume(limit=limit) while True: try: six.next(it) except StopIteration: return def consume_in_thread(self): """Consumer from all queues/consumers in a greenthread.""" @excutils.forever_retry_uncaught_exceptions def _consumer_thread(): try: self.consume() except greenlet.GreenletExit: return if self.consumer_thread is None: self.consumer_thread = eventlet.spawn(_consumer_thread) return self.consumer_thread def create_consumer(self, topic, proxy, fanout=False): """Create a consumer that calls a method in a proxy object.""" proxy_cb = rpc_amqp.ProxyCallback( self.conf, proxy, rpc_amqp.get_connection_pool(self.conf, Connection)) self.proxy_callbacks.append(proxy_cb) if fanout: self.declare_fanout_consumer(topic, proxy_cb) else: self.declare_topic_consumer(topic, proxy_cb) def create_worker(self, topic, proxy, pool_name): """Create a worker that calls a method in a proxy object.""" proxy_cb = rpc_amqp.ProxyCallback( self.conf, proxy, rpc_amqp.get_connection_pool(self.conf, Connection)) self.proxy_callbacks.append(proxy_cb) self.declare_topic_consumer(topic, proxy_cb, pool_name) def join_consumer_pool(self, callback, pool_name, topic, exchange_name=None, ack_on_error=True): """Register as a member of a group of consumers for a given topic from the specified exchange. Exactly one member of a given pool will receive each message. A message will be delivered to multiple pools, if more than one is created. """ callback_wrapper = rpc_amqp.CallbackWrapper( conf=self.conf, callback=callback, connection_pool=rpc_amqp.get_connection_pool(self.conf, Connection), wait_for_consumers=not ack_on_error ) self.proxy_callbacks.append(callback_wrapper) self.declare_topic_consumer( queue_name=pool_name, topic=topic, exchange_name=exchange_name, callback=callback_wrapper, ack_on_error=ack_on_error, ) def create_connection(conf, new=True): """Create a connection.""" return rpc_amqp.create_connection( conf, new, rpc_amqp.get_connection_pool(conf, Connection)) def multicall(conf, context, topic, msg, timeout=None): """Make a call that returns multiple times.""" return rpc_amqp.multicall( conf, context, topic, msg, timeout, rpc_amqp.get_connection_pool(conf, Connection)) def call(conf, context, topic, msg, timeout=None): """Sends a message on a topic and wait for a response.""" return rpc_amqp.call( conf, context, topic, msg, timeout, rpc_amqp.get_connection_pool(conf, Connection)) def cast(conf, context, topic, msg): """Sends a message on a topic without waiting for a response.""" return rpc_amqp.cast( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def fanout_cast(conf, context, topic, msg): """Sends a message on a fanout exchange without waiting for a response.""" return rpc_amqp.fanout_cast( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def cast_to_server(conf, context, server_params, topic, msg): """Sends a message on a topic to a specific server.""" return rpc_amqp.cast_to_server( conf, context, server_params, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def fanout_cast_to_server(conf, context, server_params, topic, msg): """Sends a message on a fanout exchange to a specific server.""" return rpc_amqp.fanout_cast_to_server( conf, context, server_params, topic, msg, rpc_amqp.get_connection_pool(conf, Connection)) def notify(conf, context, topic, msg, envelope): """Sends a notification event on a topic.""" return rpc_amqp.notify( conf, context, topic, msg, rpc_amqp.get_connection_pool(conf, Connection), envelope) def cleanup(): return rpc_amqp.cleanup(Connection.pool) heat-2014.1.5/heat/openstack/common/rpc/amqp.py0000664000567000056700000005607612540642614022343 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # Copyright 2011 - 2012, Red Hat, Inc. # # 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. """ Shared code between AMQP based openstack.common.rpc implementations. The code in this module is shared between the rpc implementations based on AMQP. Specifically, this includes impl_kombu and impl_qpid. impl_carrot also uses AMQP, but is deprecated and predates this code. """ import collections import inspect import sys import uuid from eventlet import greenpool from eventlet import pools from eventlet import queue from eventlet import semaphore from oslo.config import cfg import six from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import local from heat.openstack.common import log as logging from heat.openstack.common.rpc import common as rpc_common amqp_opts = [ cfg.BoolOpt('amqp_durable_queues', default=False, deprecated_name='rabbit_durable_queues', deprecated_group='DEFAULT', help='Use durable queues in amqp.'), cfg.BoolOpt('amqp_auto_delete', default=False, help='Auto-delete queues in amqp.'), ] cfg.CONF.register_opts(amqp_opts) UNIQUE_ID = '_unique_id' LOG = logging.getLogger(__name__) class Pool(pools.Pool): """Class that implements a Pool of Connections.""" def __init__(self, conf, connection_cls, *args, **kwargs): self.connection_cls = connection_cls self.conf = conf kwargs.setdefault("max_size", self.conf.rpc_conn_pool_size) kwargs.setdefault("order_as_stack", True) super(Pool, self).__init__(*args, **kwargs) self.reply_proxy = None # TODO(comstud): Timeout connections not used in a while def create(self): LOG.debug(_('Pool creating new connection')) return self.connection_cls(self.conf) def empty(self): while self.free_items: self.get().close() # Force a new connection pool to be created. # Note that this was added due to failing unit test cases. The issue # is the above "while loop" gets all the cached connections from the # pool and closes them, but never returns them to the pool, a pool # leak. The unit tests hang waiting for an item to be returned to the # pool. The unit tests get here via the tearDown() method. In the run # time code, it gets here via cleanup() and only appears in service.py # just before doing a sys.exit(), so cleanup() only happens once and # the leakage is not a problem. self.connection_cls.pool = None _pool_create_sem = semaphore.Semaphore() def get_connection_pool(conf, connection_cls): with _pool_create_sem: # Make sure only one thread tries to create the connection pool. if not connection_cls.pool: connection_cls.pool = Pool(conf, connection_cls) return connection_cls.pool class ConnectionContext(rpc_common.Connection): """The class that is actually returned to the create_connection() caller. This is essentially a wrapper around Connection that supports 'with'. It can also return a new Connection, or one from a pool. The function will also catch when an instance of this class is to be deleted. With that we can return Connections to the pool on exceptions and so forth without making the caller be responsible for catching them. If possible the function makes sure to return a connection to the pool. """ def __init__(self, conf, connection_pool, pooled=True, server_params=None): """Create a new connection, or get one from the pool.""" self.connection = None self.conf = conf self.connection_pool = connection_pool if pooled: self.connection = connection_pool.get() else: self.connection = connection_pool.connection_cls( conf, server_params=server_params) self.pooled = pooled def __enter__(self): """When with ConnectionContext() is used, return self.""" return self def _done(self): """If the connection came from a pool, clean it up and put it back. If it did not come from a pool, close it. """ if self.connection: if self.pooled: # Reset the connection so it's ready for the next caller # to grab from the pool self.connection.reset() self.connection_pool.put(self.connection) else: try: self.connection.close() except Exception: pass self.connection = None def __exit__(self, exc_type, exc_value, tb): """End of 'with' statement. We're done here.""" self._done() def __del__(self): """Caller is done with this connection. Make sure we cleaned up.""" self._done() def close(self): """Caller is done with this connection.""" self._done() def create_consumer(self, topic, proxy, fanout=False): self.connection.create_consumer(topic, proxy, fanout) def create_worker(self, topic, proxy, pool_name): self.connection.create_worker(topic, proxy, pool_name) def join_consumer_pool(self, callback, pool_name, topic, exchange_name, ack_on_error=True): self.connection.join_consumer_pool(callback, pool_name, topic, exchange_name, ack_on_error) def consume_in_thread(self): self.connection.consume_in_thread() def __getattr__(self, key): """Proxy all other calls to the Connection instance.""" if self.connection: return getattr(self.connection, key) else: raise rpc_common.InvalidRPCConnectionReuse() class ReplyProxy(ConnectionContext): """Connection class for RPC replies / callbacks.""" def __init__(self, conf, connection_pool): self._call_waiters = {} self._num_call_waiters = 0 self._num_call_waiters_wrn_threshold = 10 self._reply_q = 'reply_' + uuid.uuid4().hex super(ReplyProxy, self).__init__(conf, connection_pool, pooled=False) self.declare_direct_consumer(self._reply_q, self._process_data) self.consume_in_thread() def _process_data(self, message_data): msg_id = message_data.pop('_msg_id', None) waiter = self._call_waiters.get(msg_id) if not waiter: LOG.warn(_('No calling threads waiting for msg_id : %(msg_id)s' ', message : %(data)s'), {'msg_id': msg_id, 'data': message_data}) LOG.warn(_('_call_waiters: %s') % str(self._call_waiters)) else: waiter.put(message_data) def add_call_waiter(self, waiter, msg_id): self._num_call_waiters += 1 if self._num_call_waiters > self._num_call_waiters_wrn_threshold: LOG.warn(_('Number of call waiters is greater than warning ' 'threshold: %d. There could be a MulticallProxyWaiter ' 'leak.') % self._num_call_waiters_wrn_threshold) self._num_call_waiters_wrn_threshold *= 2 self._call_waiters[msg_id] = waiter def del_call_waiter(self, msg_id): self._num_call_waiters -= 1 del self._call_waiters[msg_id] def get_reply_q(self): return self._reply_q def msg_reply(conf, msg_id, reply_q, connection_pool, reply=None, failure=None, ending=False, log_failure=True): """Sends a reply or an error on the channel signified by msg_id. Failure should be a sys.exc_info() tuple. """ with ConnectionContext(conf, connection_pool) as conn: if failure: failure = rpc_common.serialize_remote_exception(failure, log_failure) msg = {'result': reply, 'failure': failure} if ending: msg['ending'] = True _add_unique_id(msg) # If a reply_q exists, add the msg_id to the reply and pass the # reply_q to direct_send() to use it as the response queue. # Otherwise use the msg_id for backward compatibility. if reply_q: msg['_msg_id'] = msg_id conn.direct_send(reply_q, rpc_common.serialize_msg(msg)) else: conn.direct_send(msg_id, rpc_common.serialize_msg(msg)) class RpcContext(rpc_common.CommonRpcContext): """Context that supports replying to a rpc.call.""" def __init__(self, **kwargs): self.msg_id = kwargs.pop('msg_id', None) self.reply_q = kwargs.pop('reply_q', None) self.conf = kwargs.pop('conf') super(RpcContext, self).__init__(**kwargs) def deepcopy(self): values = self.to_dict() values['conf'] = self.conf values['msg_id'] = self.msg_id values['reply_q'] = self.reply_q return self.__class__(**values) def reply(self, reply=None, failure=None, ending=False, connection_pool=None, log_failure=True): if self.msg_id: msg_reply(self.conf, self.msg_id, self.reply_q, connection_pool, reply, failure, ending, log_failure) if ending: self.msg_id = None def unpack_context(conf, msg): """Unpack context from msg.""" context_dict = {} for key in list(msg.keys()): # NOTE(vish): Some versions of python don't like unicode keys # in kwargs. key = str(key) if key.startswith('_context_'): value = msg.pop(key) context_dict[key[9:]] = value context_dict['msg_id'] = msg.pop('_msg_id', None) context_dict['reply_q'] = msg.pop('_reply_q', None) context_dict['conf'] = conf ctx = RpcContext.from_dict(context_dict) rpc_common._safe_log(LOG.debug, _('unpacked context: %s'), ctx.to_dict()) return ctx def pack_context(msg, context): """Pack context into msg. Values for message keys need to be less than 255 chars, so we pull context out into a bunch of separate keys. If we want to support more arguments in rabbit messages, we may want to do the same for args at some point. """ if isinstance(context, dict): context_d = dict([('_context_%s' % key, value) for (key, value) in six.iteritems(context)]) else: context_d = dict([('_context_%s' % key, value) for (key, value) in six.iteritems(context.to_dict())]) msg.update(context_d) class _MsgIdCache(object): """This class checks any duplicate messages.""" # NOTE: This value is considered can be a configuration item, but # it is not necessary to change its value in most cases, # so let this value as static for now. DUP_MSG_CHECK_SIZE = 16 def __init__(self, **kwargs): self.prev_msgids = collections.deque([], maxlen=self.DUP_MSG_CHECK_SIZE) def check_duplicate_message(self, message_data): """AMQP consumers may read same message twice when exceptions occur before ack is returned. This method prevents doing it. """ if UNIQUE_ID in message_data: msg_id = message_data[UNIQUE_ID] if msg_id not in self.prev_msgids: self.prev_msgids.append(msg_id) else: raise rpc_common.DuplicateMessageError(msg_id=msg_id) def _add_unique_id(msg): """Add unique_id for checking duplicate messages.""" unique_id = uuid.uuid4().hex msg.update({UNIQUE_ID: unique_id}) LOG.debug(_('UNIQUE_ID is %s.') % (unique_id)) class _ThreadPoolWithWait(object): """Base class for a delayed invocation manager. Used by the Connection class to start up green threads to handle incoming messages. """ def __init__(self, conf, connection_pool): self.pool = greenpool.GreenPool(conf.rpc_thread_pool_size) self.connection_pool = connection_pool self.conf = conf def wait(self): """Wait for all callback threads to exit.""" self.pool.waitall() class CallbackWrapper(_ThreadPoolWithWait): """Wraps a straight callback. Allows it to be invoked in a green thread. """ def __init__(self, conf, callback, connection_pool, wait_for_consumers=False): """Initiates CallbackWrapper object. :param conf: cfg.CONF instance :param callback: a callable (probably a function) :param connection_pool: connection pool as returned by get_connection_pool() :param wait_for_consumers: wait for all green threads to complete and raise the last caught exception, if any. """ super(CallbackWrapper, self).__init__( conf=conf, connection_pool=connection_pool, ) self.callback = callback self.wait_for_consumers = wait_for_consumers self.exc_info = None def _wrap(self, message_data, **kwargs): """Wrap the callback invocation to catch exceptions. """ try: self.callback(message_data, **kwargs) except Exception: self.exc_info = sys.exc_info() def __call__(self, message_data): self.exc_info = None self.pool.spawn_n(self._wrap, message_data) if self.wait_for_consumers: self.pool.waitall() if self.exc_info: six.reraise(self.exc_info[1], None, self.exc_info[2]) class ProxyCallback(_ThreadPoolWithWait): """Calls methods on a proxy object based on method and args.""" def __init__(self, conf, proxy, connection_pool): super(ProxyCallback, self).__init__( conf=conf, connection_pool=connection_pool, ) self.proxy = proxy self.msg_id_cache = _MsgIdCache() def __call__(self, message_data): """Consumer callback to call a method on a proxy object. Parses the message for validity and fires off a thread to call the proxy object method. Message data should be a dictionary with two keys: method: string representing the method to call args: dictionary of arg: value Example: {'method': 'echo', 'args': {'value': 42}} """ # It is important to clear the context here, because at this point # the previous context is stored in local.store.context if hasattr(local.store, 'context'): del local.store.context rpc_common._safe_log(LOG.debug, _('received %s'), message_data) self.msg_id_cache.check_duplicate_message(message_data) ctxt = unpack_context(self.conf, message_data) method = message_data.get('method') args = message_data.get('args', {}) version = message_data.get('version') namespace = message_data.get('namespace') if not method: LOG.warn(_('no method for message: %s') % message_data) ctxt.reply(_('No method for message: %s') % message_data, connection_pool=self.connection_pool) return self.pool.spawn_n(self._process_data, ctxt, version, method, namespace, args) def _process_data(self, ctxt, version, method, namespace, args): """Process a message in a new thread. If the proxy object we have has a dispatch method (see rpc.dispatcher.RpcDispatcher), pass it the version, method, and args and let it dispatch as appropriate. If not, use the old behavior of magically calling the specified method on the proxy we have here. """ ctxt.update_store() try: rval = self.proxy.dispatch(ctxt, version, method, namespace, **args) # Check if the result was a generator if inspect.isgenerator(rval): for x in rval: ctxt.reply(x, None, connection_pool=self.connection_pool) else: ctxt.reply(rval, None, connection_pool=self.connection_pool) # This final None tells multicall that it is done. ctxt.reply(ending=True, connection_pool=self.connection_pool) except rpc_common.ClientException as e: LOG.debug(_('Expected exception during message handling (%s)') % e._exc_info[1]) ctxt.reply(None, e._exc_info, connection_pool=self.connection_pool, log_failure=False) except Exception: # sys.exc_info() is deleted by LOG.exception(). exc_info = sys.exc_info() LOG.error(_('Exception during message handling'), exc_info=exc_info) ctxt.reply(None, exc_info, connection_pool=self.connection_pool) class MulticallProxyWaiter(object): def __init__(self, conf, msg_id, timeout, connection_pool): self._msg_id = msg_id self._timeout = timeout or conf.rpc_response_timeout self._reply_proxy = connection_pool.reply_proxy self._done = False self._got_ending = False self._conf = conf self._dataqueue = queue.LightQueue() # Add this caller to the reply proxy's call_waiters self._reply_proxy.add_call_waiter(self, self._msg_id) self.msg_id_cache = _MsgIdCache() def put(self, data): self._dataqueue.put(data) def done(self): if self._done: return self._done = True # Remove this caller from reply proxy's call_waiters self._reply_proxy.del_call_waiter(self._msg_id) def _process_data(self, data): result = None self.msg_id_cache.check_duplicate_message(data) if data['failure']: failure = data['failure'] result = rpc_common.deserialize_remote_exception(self._conf, failure) elif data.get('ending', False): self._got_ending = True else: result = data['result'] return result def __iter__(self): """Return a result until we get a reply with an 'ending' flag.""" if self._done: raise StopIteration while True: try: data = self._dataqueue.get(timeout=self._timeout) result = self._process_data(data) except queue.Empty: self.done() raise rpc_common.Timeout() except Exception: with excutils.save_and_reraise_exception(): self.done() if self._got_ending: self.done() raise StopIteration if isinstance(result, Exception): self.done() raise result yield result def create_connection(conf, new, connection_pool): """Create a connection.""" return ConnectionContext(conf, connection_pool, pooled=not new) _reply_proxy_create_sem = semaphore.Semaphore() def multicall(conf, context, topic, msg, timeout, connection_pool): """Make a call that returns multiple times.""" LOG.debug(_('Making synchronous call on %s ...'), topic) msg_id = uuid.uuid4().hex msg.update({'_msg_id': msg_id}) LOG.debug(_('MSG_ID is %s') % (msg_id)) _add_unique_id(msg) pack_context(msg, context) with _reply_proxy_create_sem: if not connection_pool.reply_proxy: connection_pool.reply_proxy = ReplyProxy(conf, connection_pool) msg.update({'_reply_q': connection_pool.reply_proxy.get_reply_q()}) wait_msg = MulticallProxyWaiter(conf, msg_id, timeout, connection_pool) with ConnectionContext(conf, connection_pool) as conn: conn.topic_send(topic, rpc_common.serialize_msg(msg), timeout) return wait_msg def call(conf, context, topic, msg, timeout, connection_pool): """Sends a message on a topic and wait for a response.""" rv = multicall(conf, context, topic, msg, timeout, connection_pool) # NOTE(vish): return the last result from the multicall rv = list(rv) if not rv: return return rv[-1] def cast(conf, context, topic, msg, connection_pool): """Sends a message on a topic without waiting for a response.""" LOG.debug(_('Making asynchronous cast on %s...'), topic) _add_unique_id(msg) pack_context(msg, context) with ConnectionContext(conf, connection_pool) as conn: conn.topic_send(topic, rpc_common.serialize_msg(msg)) def fanout_cast(conf, context, topic, msg, connection_pool): """Sends a message on a fanout exchange without waiting for a response.""" LOG.debug(_('Making asynchronous fanout cast...')) _add_unique_id(msg) pack_context(msg, context) with ConnectionContext(conf, connection_pool) as conn: conn.fanout_send(topic, rpc_common.serialize_msg(msg)) def cast_to_server(conf, context, server_params, topic, msg, connection_pool): """Sends a message on a topic to a specific server.""" _add_unique_id(msg) pack_context(msg, context) with ConnectionContext(conf, connection_pool, pooled=False, server_params=server_params) as conn: conn.topic_send(topic, rpc_common.serialize_msg(msg)) def fanout_cast_to_server(conf, context, server_params, topic, msg, connection_pool): """Sends a message on a fanout exchange to a specific server.""" _add_unique_id(msg) pack_context(msg, context) with ConnectionContext(conf, connection_pool, pooled=False, server_params=server_params) as conn: conn.fanout_send(topic, rpc_common.serialize_msg(msg)) def notify(conf, context, topic, msg, connection_pool, envelope): """Sends a notification event on a topic.""" LOG.debug(_('Sending %(event_type)s on %(topic)s'), dict(event_type=msg.get('event_type'), topic=topic)) _add_unique_id(msg) pack_context(msg, context) with ConnectionContext(conf, connection_pool) as conn: if envelope: msg = rpc_common.serialize_msg(msg) conn.notify_send(topic, msg) def cleanup(connection_pool): if connection_pool: connection_pool.empty() def get_control_exchange(conf): return conf.control_exchange heat-2014.1.5/heat/openstack/common/rpc/service.py0000664000567000056700000000537612540642614023042 0ustar jenkinsjenkins00000000000000# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # Copyright 2011 Red Hat, Inc. # # 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. from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import rpc from heat.openstack.common.rpc import dispatcher as rpc_dispatcher from heat.openstack.common import service LOG = logging.getLogger(__name__) class Service(service.Service): """Service object for binaries running on hosts. A service enables rpc by listening to queues based on topic and host. """ def __init__(self, host, topic, manager=None, serializer=None): super(Service, self).__init__() self.host = host self.topic = topic self.serializer = serializer if manager is None: self.manager = self else: self.manager = manager def start(self): super(Service, self).start() self.conn = rpc.create_connection(new=True) LOG.debug(_("Creating Consumer connection for Service %s") % self.topic) dispatcher = rpc_dispatcher.RpcDispatcher([self.manager], self.serializer) # Share this same connection for these Consumers self.conn.create_consumer(self.topic, dispatcher, fanout=False) node_topic = '%s.%s' % (self.topic, self.host) self.conn.create_consumer(node_topic, dispatcher, fanout=False) self.conn.create_consumer(self.topic, dispatcher, fanout=True) # Hook to allow the manager to do other initializations after # the rpc connection is created. if callable(getattr(self.manager, 'initialize_service_hook', None)): self.manager.initialize_service_hook(self) # Consume from all consumers in a thread self.conn.consume_in_thread() def stop(self): # Try to shut the connection down, but if we get any sort of # errors, go ahead and ignore them.. as we're shutting down anyway try: self.conn.close() except Exception: pass super(Service, self).stop() heat-2014.1.5/heat/openstack/common/rpc/proxy.py0000664000567000056700000002234112540642614022552 0ustar jenkinsjenkins00000000000000# Copyright 2012-2013 Red Hat, Inc. # # 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. """ A helper class for proxy objects to remote APIs. For more information about rpc API version numbers, see: rpc/dispatcher.py """ import six from heat.openstack.common import rpc from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common.rpc import serializer as rpc_serializer class RpcProxy(object): """A helper class for rpc clients. This class is a wrapper around the RPC client API. It allows you to specify the topic and API version in a single place. This is intended to be used as a base class for a class that implements the client side of an rpc API. """ # The default namespace, which can be overridden in a subclass. RPC_API_NAMESPACE = None def __init__(self, topic, default_version, version_cap=None, serializer=None): """Initialize an RpcProxy. :param topic: The topic to use for all messages. :param default_version: The default API version to request in all outgoing messages. This can be overridden on a per-message basis. :param version_cap: Optionally cap the maximum version used for sent messages. :param serializer: Optionaly (de-)serialize entities with a provided helper. """ self.topic = topic self.default_version = default_version self.version_cap = version_cap if serializer is None: serializer = rpc_serializer.NoOpSerializer() self.serializer = serializer super(RpcProxy, self).__init__() def _set_version(self, msg, vers): """Helper method to set the version in a message. :param msg: The message having a version added to it. :param vers: The version number to add to the message. """ v = vers if vers else self.default_version if (self.version_cap and not rpc_common.version_is_compatible(self.version_cap, v)): raise rpc_common.RpcVersionCapError(version_cap=self.version_cap) msg['version'] = v def _get_topic(self, topic): """Return the topic to use for a message.""" return topic if topic else self.topic def can_send_version(self, version): """Check to see if a version is compatible with the version cap.""" return (not self.version_cap or rpc_common.version_is_compatible(self.version_cap, version)) @staticmethod def make_namespaced_msg(method, namespace, **kwargs): return {'method': method, 'namespace': namespace, 'args': kwargs} def make_msg(self, method, **kwargs): return self.make_namespaced_msg(method, self.RPC_API_NAMESPACE, **kwargs) def _serialize_msg_args(self, context, kwargs): """Helper method called to serialize message arguments. This calls our serializer on each argument, returning a new set of args that have been serialized. :param context: The request context :param kwargs: The arguments to serialize :returns: A new set of serialized arguments """ new_kwargs = dict() for argname, arg in six.iteritems(kwargs): new_kwargs[argname] = self.serializer.serialize_entity(context, arg) return new_kwargs def call(self, context, msg, topic=None, version=None, timeout=None): """rpc.call() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :param timeout: (Optional) A timeout to use when waiting for the response. If no timeout is specified, a default timeout will be used that is usually sufficient. :returns: The return value from the remote method. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) real_topic = self._get_topic(topic) try: result = rpc.call(context, real_topic, msg, timeout) return self.serializer.deserialize_entity(context, result) except rpc.common.Timeout as exc: raise rpc.common.Timeout( exc.info, real_topic, msg.get('method')) def multicall(self, context, msg, topic=None, version=None, timeout=None): """rpc.multicall() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :param timeout: (Optional) A timeout to use when waiting for the response. If no timeout is specified, a default timeout will be used that is usually sufficient. :returns: An iterator that lets you process each of the returned values from the remote method as they arrive. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) real_topic = self._get_topic(topic) try: result = rpc.multicall(context, real_topic, msg, timeout) return self.serializer.deserialize_entity(context, result) except rpc.common.Timeout as exc: raise rpc.common.Timeout( exc.info, real_topic, msg.get('method')) def cast(self, context, msg, topic=None, version=None): """rpc.cast() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.cast() does not wait on any return value from the remote method. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.cast(context, self._get_topic(topic), msg) def fanout_cast(self, context, msg, topic=None, version=None): """rpc.fanout_cast() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.fanout_cast() does not wait on any return value from the remote method. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.fanout_cast(context, self._get_topic(topic), msg) def cast_to_server(self, context, server_params, msg, topic=None, version=None): """rpc.cast_to_server() a remote method. :param context: The request context :param server_params: Server parameters. See rpc.cast_to_server() for details. :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.cast_to_server() does not wait on any return values. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.cast_to_server(context, server_params, self._get_topic(topic), msg) def fanout_cast_to_server(self, context, server_params, msg, topic=None, version=None): """rpc.fanout_cast_to_server() a remote method. :param context: The request context :param server_params: Server parameters. See rpc.cast_to_server() for details. :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.fanout_cast_to_server() does not wait on any return values. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.fanout_cast_to_server(context, server_params, self._get_topic(topic), msg) heat-2014.1.5/heat/openstack/common/rpc/dispatcher.py0000664000567000056700000001553412540642614023525 0ustar jenkinsjenkins00000000000000# Copyright 2012 Red Hat, Inc. # # 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. """ Code for rpc message dispatching. Messages that come in have a version number associated with them. RPC API version numbers are in the form: Major.Minor For a given message with version X.Y, the receiver must be marked as able to handle messages of version A.B, where: A = X B >= Y The Major version number would be incremented for an almost completely new API. The Minor version number would be incremented for backwards compatible changes to an existing API. A backwards compatible change could be something like adding a new method, adding an argument to an existing method (but not requiring it), or changing the type for an existing argument (but still handling the old type as well). The conversion over to a versioned API must be done on both the client side and server side of the API at the same time. However, as the code stands today, there can be both versioned and unversioned APIs implemented in the same code base. EXAMPLES ======== Nova was the first project to use versioned rpc APIs. Consider the compute rpc API as an example. The client side is in nova/compute/rpcapi.py and the server side is in nova/compute/manager.py. Example 1) Adding a new method. ------------------------------- Adding a new method is a backwards compatible change. It should be added to nova/compute/manager.py, and RPC_API_VERSION should be bumped from X.Y to X.Y+1. On the client side, the new method in nova/compute/rpcapi.py should have a specific version specified to indicate the minimum API version that must be implemented for the method to be supported. For example:: def get_host_uptime(self, ctxt, host): topic = _compute_topic(self.topic, ctxt, host, None) return self.call(ctxt, self.make_msg('get_host_uptime'), topic, version='1.1') In this case, version '1.1' is the first version that supported the get_host_uptime() method. Example 2) Adding a new parameter. ---------------------------------- Adding a new parameter to an rpc method can be made backwards compatible. The RPC_API_VERSION on the server side (nova/compute/manager.py) should be bumped. The implementation of the method must not expect the parameter to be present.:: def some_remote_method(self, arg1, arg2, newarg=None): # The code needs to deal with newarg=None for cases # where an older client sends a message without it. pass On the client side, the same changes should be made as in example 1. The minimum version that supports the new parameter should be specified. """ import six from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common.rpc import serializer as rpc_serializer class RpcDispatcher(object): """Dispatch rpc messages according to the requested API version. This class can be used as the top level 'manager' for a service. It contains a list of underlying managers that have an API_VERSION attribute. """ def __init__(self, callbacks, serializer=None): """Initialize the rpc dispatcher. :param callbacks: List of proxy objects that are an instance of a class with rpc methods exposed. Each proxy object should have an RPC_API_VERSION attribute. :param serializer: The Serializer object that will be used to deserialize arguments before the method call and to serialize the result after it returns. """ self.callbacks = callbacks if serializer is None: serializer = rpc_serializer.NoOpSerializer() self.serializer = serializer super(RpcDispatcher, self).__init__() def _deserialize_args(self, context, kwargs): """Helper method called to deserialize args before dispatch. This calls our serializer on each argument, returning a new set of args that have been deserialized. :param context: The request context :param kwargs: The arguments to be deserialized :returns: A new set of deserialized args """ new_kwargs = dict() for argname, arg in six.iteritems(kwargs): new_kwargs[argname] = self.serializer.deserialize_entity(context, arg) return new_kwargs def dispatch(self, ctxt, version, method, namespace, **kwargs): """Dispatch a message based on a requested version. :param ctxt: The request context :param version: The requested API version from the incoming message :param method: The method requested to be called by the incoming message. :param namespace: The namespace for the requested method. If None, the dispatcher will look for a method on a callback object with no namespace set. :param kwargs: A dict of keyword arguments to be passed to the method. :returns: Whatever is returned by the underlying method that gets called. """ if not version: version = '1.0' had_compatible = False for proxyobj in self.callbacks: # Check for namespace compatibility try: cb_namespace = proxyobj.RPC_API_NAMESPACE except AttributeError: cb_namespace = None if namespace != cb_namespace: continue # Check for version compatibility try: rpc_api_version = proxyobj.RPC_API_VERSION except AttributeError: rpc_api_version = '1.0' is_compatible = rpc_common.version_is_compatible(rpc_api_version, version) had_compatible = had_compatible or is_compatible if not hasattr(proxyobj, method): continue if is_compatible: kwargs = self._deserialize_args(ctxt, kwargs) result = getattr(proxyobj, method)(ctxt, **kwargs) return self.serializer.serialize_entity(ctxt, result) if had_compatible: raise AttributeError("No such RPC function '%s'" % method) else: raise rpc_common.UnsupportedRpcVersion(version=version) heat-2014.1.5/heat/openstack/common/rpc/matchmaker_redis.py0000664000567000056700000001130012540642614024664 0ustar jenkinsjenkins00000000000000# Copyright 2013 Cloudscaling Group, Inc # # 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. """ The MatchMaker classes should accept a Topic or Fanout exchange key and return keys for direct exchanges, per (approximate) AMQP parlance. """ from oslo.config import cfg from heat.openstack.common import importutils from heat.openstack.common import log as logging from heat.openstack.common.rpc import matchmaker as mm_common redis = importutils.try_import('redis') matchmaker_redis_opts = [ cfg.StrOpt('host', default='127.0.0.1', help='Host to locate redis'), cfg.IntOpt('port', default=6379, help='Use this port to connect to redis host.'), cfg.StrOpt('password', default=None, help='Password for Redis server. (optional)'), ] CONF = cfg.CONF opt_group = cfg.OptGroup(name='matchmaker_redis', title='Options for Redis-based MatchMaker') CONF.register_group(opt_group) CONF.register_opts(matchmaker_redis_opts, opt_group) LOG = logging.getLogger(__name__) class RedisExchange(mm_common.Exchange): def __init__(self, matchmaker): self.matchmaker = matchmaker self.redis = matchmaker.redis super(RedisExchange, self).__init__() class RedisTopicExchange(RedisExchange): """Exchange where all topic keys are split, sending to second half. i.e. "compute.host" sends a message to "compute" running on "host" """ def run(self, topic): while True: member_name = self.redis.srandmember(topic) if not member_name: # If this happens, there are no # longer any members. break if not self.matchmaker.is_alive(topic, member_name): continue host = member_name.split('.', 1)[1] return [(member_name, host)] return [] class RedisFanoutExchange(RedisExchange): """Return a list of all hosts.""" def run(self, topic): topic = topic.split('~', 1)[1] hosts = self.redis.smembers(topic) good_hosts = filter( lambda host: self.matchmaker.is_alive(topic, host), hosts) return [(x, x.split('.', 1)[1]) for x in good_hosts] class MatchMakerRedis(mm_common.HeartbeatMatchMakerBase): """MatchMaker registering and looking-up hosts with a Redis server.""" def __init__(self): super(MatchMakerRedis, self).__init__() if not redis: raise ImportError("Failed to import module redis.") self.redis = redis.Redis( host=CONF.matchmaker_redis.host, port=CONF.matchmaker_redis.port, password=CONF.matchmaker_redis.password) self.add_binding(mm_common.FanoutBinding(), RedisFanoutExchange(self)) self.add_binding(mm_common.DirectBinding(), mm_common.DirectExchange()) self.add_binding(mm_common.TopicBinding(), RedisTopicExchange(self)) def ack_alive(self, key, host): topic = "%s.%s" % (key, host) if not self.redis.expire(topic, CONF.matchmaker_heartbeat_ttl): # If we could not update the expiration, the key # might have been pruned. Re-register, creating a new # key in Redis. self.register(self.topic_host[host], host) def is_alive(self, topic, host): if self.redis.ttl(host) == -1: self.expire(topic, host) return False return True def expire(self, topic, host): with self.redis.pipeline() as pipe: pipe.multi() pipe.delete(host) pipe.srem(topic, host) pipe.execute() def backend_register(self, key, key_host): with self.redis.pipeline() as pipe: pipe.multi() pipe.sadd(key, key_host) # No value is needed, we just # care if it exists. Sets aren't viable # because only keys can expire. pipe.set(key_host, '') pipe.execute() def backend_unregister(self, key, key_host): with self.redis.pipeline() as pipe: pipe.multi() pipe.srem(key, key_host) pipe.delete(key_host) pipe.execute() heat-2014.1.5/heat/openstack/common/py3kcompat/0000775000567000056700000000000012540643116022321 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/py3kcompat/__init__.py0000664000567000056700000000000012540642614024422 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/openstack/common/py3kcompat/urlutils.py0000664000567000056700000000356012540642614024564 0ustar jenkinsjenkins00000000000000# # Copyright 2013 Canonical Ltd. # 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. # """ Python2/Python3 compatibility layer for OpenStack """ import six if six.PY3: # python3 import urllib.error import urllib.parse import urllib.request urlencode = urllib.parse.urlencode urljoin = urllib.parse.urljoin quote = urllib.parse.quote quote_plus = urllib.parse.quote_plus parse_qsl = urllib.parse.parse_qsl unquote = urllib.parse.unquote unquote_plus = urllib.parse.unquote_plus urlparse = urllib.parse.urlparse urlsplit = urllib.parse.urlsplit urlunsplit = urllib.parse.urlunsplit SplitResult = urllib.parse.SplitResult urlopen = urllib.request.urlopen URLError = urllib.error.URLError pathname2url = urllib.request.pathname2url else: # python2 import urllib import urllib2 import urlparse urlencode = urllib.urlencode quote = urllib.quote quote_plus = urllib.quote_plus unquote = urllib.unquote unquote_plus = urllib.unquote_plus parse = urlparse parse_qsl = parse.parse_qsl urljoin = parse.urljoin urlparse = parse.urlparse urlsplit = parse.urlsplit urlunsplit = parse.urlunsplit SplitResult = parse.SplitResult urlopen = urllib2.urlopen URLError = urllib2.URLError pathname2url = urllib.pathname2url heat-2014.1.5/heat/openstack/common/strutils.py0000664000567000056700000001657012540642614022505 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. """ System-level utilities and helper functions. """ import re import sys import unicodedata import six from heat.openstack.common.gettextutils import _ # Used for looking up extensions of text # to their 'multiplied' byte amount BYTE_MULTIPLIERS = { '': 1, 't': 1024 ** 4, 'g': 1024 ** 3, 'm': 1024 ** 2, 'k': 1024, } BYTE_REGEX = re.compile(r'(^-?\d+)(\D*)') TRUE_STRINGS = ('1', 't', 'true', 'on', 'y', 'yes') FALSE_STRINGS = ('0', 'f', 'false', 'off', 'n', 'no') SLUGIFY_STRIP_RE = re.compile(r"[^\w\s-]") SLUGIFY_HYPHENATE_RE = re.compile(r"[-\s]+") def int_from_bool_as_string(subject): """Interpret a string as a boolean and return either 1 or 0. Any string value in: ('True', 'true', 'On', 'on', '1') is interpreted as a boolean True. Useful for JSON-decoded stuff and config file parsing """ return bool_from_string(subject) and 1 or 0 def bool_from_string(subject, strict=False, default=False): """Interpret a string as a boolean. A case-insensitive match is performed such that strings matching 't', 'true', 'on', 'y', 'yes', or '1' are considered True and, when `strict=False`, anything else returns the value specified by 'default'. Useful for JSON-decoded stuff and config file parsing. If `strict=True`, unrecognized values, including None, will raise a ValueError which is useful when parsing values passed in from an API call. Strings yielding False are 'f', 'false', 'off', 'n', 'no', or '0'. """ if not isinstance(subject, six.string_types): subject = str(subject) lowered = subject.strip().lower() if lowered in TRUE_STRINGS: return True elif lowered in FALSE_STRINGS: return False elif strict: acceptable = ', '.join( "'%s'" % s for s in sorted(TRUE_STRINGS + FALSE_STRINGS)) msg = _("Unrecognized value '%(val)s', acceptable values are:" " %(acceptable)s") % {'val': subject, 'acceptable': acceptable} raise ValueError(msg) else: return default def safe_decode(text, incoming=None, errors='strict'): """Decodes incoming str using `incoming` if they're not already unicode. :param incoming: Text's current encoding :param errors: Errors handling policy. See here for valid values http://docs.python.org/2/library/codecs.html :returns: text or a unicode `incoming` encoded representation of it. :raises TypeError: If text is not an instance of str """ if not isinstance(text, six.string_types): raise TypeError("%s can't be decoded" % type(text)) if isinstance(text, six.text_type): return text if not incoming: incoming = (sys.stdin.encoding or sys.getdefaultencoding()) try: return text.decode(incoming, errors) except UnicodeDecodeError: # Note(flaper87) If we get here, it means that # sys.stdin.encoding / sys.getdefaultencoding # didn't return a suitable encoding to decode # text. This happens mostly when global LANG # var is not set correctly and there's no # default encoding. In this case, most likely # python will use ASCII or ANSI encoders as # default encodings but they won't be capable # of decoding non-ASCII characters. # # Also, UTF-8 is being used since it's an ASCII # extension. return text.decode('utf-8', errors) def safe_encode(text, incoming=None, encoding='utf-8', errors='strict'): """Encodes incoming str/unicode using `encoding`. If incoming is not specified, text is expected to be encoded with current python's default encoding. (`sys.getdefaultencoding`) :param incoming: Text's current encoding :param encoding: Expected encoding for text (Default UTF-8) :param errors: Errors handling policy. See here for valid values http://docs.python.org/2/library/codecs.html :returns: text or a bytestring `encoding` encoded representation of it. :raises TypeError: If text is not an instance of str """ if not isinstance(text, six.string_types): raise TypeError("%s can't be encoded" % type(text)) if not incoming: incoming = (sys.stdin.encoding or sys.getdefaultencoding()) if isinstance(text, six.text_type): if six.PY3: return text.encode(encoding, errors).decode(incoming) else: return text.encode(encoding, errors) elif text and encoding != incoming: # Decode text before encoding it with `encoding` text = safe_decode(text, incoming, errors) if six.PY3: return text.encode(encoding, errors).decode(incoming) else: return text.encode(encoding, errors) return text def to_bytes(text, default=0): """Converts a string into an integer of bytes. Looks at the last characters of the text to determine what conversion is needed to turn the input text into a byte number. Supports "B, K(B), M(B), G(B), and T(B)". (case insensitive) :param text: String input for bytes size conversion. :param default: Default return value when text is blank. """ match = BYTE_REGEX.search(text) if match: magnitude = int(match.group(1)) mult_key_org = match.group(2) if not mult_key_org: return magnitude elif text: msg = _('Invalid string format: %s') % text raise TypeError(msg) else: return default mult_key = mult_key_org.lower().replace('b', '', 1) multiplier = BYTE_MULTIPLIERS.get(mult_key) if multiplier is None: msg = _('Unknown byte multiplier: %s') % mult_key_org raise TypeError(msg) return magnitude * multiplier def to_slug(value, incoming=None, errors="strict"): """Normalize string. Convert to lowercase, remove non-word characters, and convert spaces to hyphens. Inspired by Django's `slugify` filter. :param value: Text to slugify :param incoming: Text's current encoding :param errors: Errors handling policy. See here for valid values http://docs.python.org/2/library/codecs.html :returns: slugified unicode representation of `value` :raises TypeError: If text is not an instance of str """ value = safe_decode(value, incoming, errors) # NOTE(aababilov): no need to use safe_(encode|decode) here: # encodings are always "ascii", error handling is always "ignore" # and types are always known (first: unicode; second: str) value = unicodedata.normalize("NFKD", value).encode( "ascii", "ignore").decode("ascii") value = SLUGIFY_STRIP_RE.sub("", value).strip().lower() return SLUGIFY_HYPHENATE_RE.sub("-", value) heat-2014.1.5/heat/openstack/common/fileutils.py0000664000567000056700000000747512540642614022620 0ustar jenkinsjenkins00000000000000# Copyright 2011 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. import contextlib import errno import os import tempfile from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging LOG = logging.getLogger(__name__) _FILE_CACHE = {} def ensure_tree(path): """Create a directory (and any ancestor directories required) :param path: Directory to create """ try: os.makedirs(path) except OSError as exc: if exc.errno == errno.EEXIST: if not os.path.isdir(path): raise else: raise def read_cached_file(filename, force_reload=False): """Read from a file if it has been modified. :param force_reload: Whether to reload the file. :returns: A tuple with a boolean specifying if the data is fresh or not. """ global _FILE_CACHE if force_reload and filename in _FILE_CACHE: del _FILE_CACHE[filename] reloaded = False mtime = os.path.getmtime(filename) cache_info = _FILE_CACHE.setdefault(filename, {}) if not cache_info or mtime > cache_info.get('mtime', 0): LOG.debug(_("Reloading cached file %s") % filename) with open(filename) as fap: cache_info['data'] = fap.read() cache_info['mtime'] = mtime reloaded = True return (reloaded, cache_info['data']) def delete_if_exists(path, remove=os.unlink): """Delete a file, but ignore file not found error. :param path: File to delete :param remove: Optional function to remove passed path """ try: remove(path) except OSError as e: if e.errno != errno.ENOENT: raise @contextlib.contextmanager def remove_path_on_error(path, remove=delete_if_exists): """Protect code that wants to operate on PATH atomically. Any exception will cause PATH to be removed. :param path: File to work with :param remove: Optional function to remove passed path """ try: yield except Exception: with excutils.save_and_reraise_exception(): remove(path) def file_open(*args, **kwargs): """Open file see built-in file() documentation for more details Note: The reason this is kept in a separate module is to easily be able to provide a stub module that doesn't alter system state at all (for unit tests) """ return file(*args, **kwargs) def write_to_tempfile(content, path=None, suffix='', prefix='tmp'): """Create temporary file or use existing file. This util is needed for creating temporary file with specified content, suffix and prefix. If path is not None, it will be used for writing content. If the path doesn't exist it'll be created. :param content: content for temporary file. :param path: same as parameter 'dir' for mkstemp :param suffix: same as parameter 'suffix' for mkstemp :param prefix: same as parameter 'prefix' for mkstemp For example: it can be used in database tests for creating configuration files. """ if path: ensure_tree(path) (fd, path) = tempfile.mkstemp(suffix=suffix, dir=path, prefix=prefix) try: os.write(fd, content) finally: os.close(fd) return path heat-2014.1.5/heat/openstack/__init__.py0000664000567000056700000000000012540642611021035 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/0000775000567000056700000000000012540643116015521 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/middleware/0000775000567000056700000000000012540643116017636 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/middleware/ssl.py0000664000567000056700000000325312540642614021016 0ustar jenkinsjenkins00000000000000# -*- encoding: 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. from oslo.config import cfg from heat.common import wsgi ssl_middleware_opts = [ cfg.StrOpt('secure_proxy_ssl_header', default='X-Forwarded-Proto', help="The HTTP Header that will be used to determine which " "the original request protocol scheme was, even if it was " "removed by an SSL terminator proxy.") ] cfg.CONF.register_opts(ssl_middleware_opts) class SSLMiddleware(wsgi.Middleware): """A middleware that replaces the request wsgi.url_scheme environment variable with the value of HTTP header configured in secure_proxy_ssl_header if exists in the incoming request. This is useful if the server is behind a SSL termination proxy. """ def __init__(self, application): super(SSLMiddleware, self).__init__(application) self.secure_proxy_ssl_header = 'HTTP_{0}'.format( cfg.CONF.secure_proxy_ssl_header.upper().replace('-', '_')) def process_request(self, req): req.environ['wsgi.url_scheme'] = req.environ.get( self.secure_proxy_ssl_header, req.environ['wsgi.url_scheme']) heat-2014.1.5/heat/api/middleware/version_negotiation.py0000664000567000056700000001233112540642614024277 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. """ A filter middleware that inspects the requested URI for a version string and/or Accept headers and attempts to negotiate an API controller to return """ import re import webob from heat.common import wsgi from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class VersionNegotiationFilter(wsgi.Middleware): def __init__(self, version_controller, app, conf, **local_conf): self.versions_app = version_controller(conf) self.version_uri_regex = re.compile(r"^v(\d+)\.?(\d+)?") self.conf = conf super(VersionNegotiationFilter, self).__init__(app) def process_request(self, req): """ If there is a version identifier in the URI, simply return the correct API controller, otherwise, if we find an Accept: header, process it """ # See if a version identifier is in the URI passed to # us already. If so, simply return the right version # API controller msg = _("Processing request: %(method)s %(path)s Accept: " "%(accept)s") % ({'method': req.method, 'path': req.path, 'accept': req.accept}) logger.debug(msg) # If the request is for /versions, just return the versions container if req.path_info_peek() in ("versions", ""): return self.versions_app match = self._match_version_string(req.path_info_peek(), req) if match: major_version = req.environ['api.major_version'] minor_version = req.environ['api.minor_version'] if (major_version == 1 and minor_version == 0): logger.debug(_("Matched versioned URI. " "Version: %(major_version)d.%(minor_version)d") % {'major_version': major_version, 'minor_version': minor_version}) # Strip the version from the path req.path_info_pop() return None else: logger.debug(_("Unknown version in versioned URI: " "%(major_version)d.%(minor_version)d. " "Returning version choices.") % {'major_version': major_version, 'minor_version': minor_version}) return self.versions_app accept = str(req.accept) if accept.startswith('application/vnd.openstack.orchestration-'): token_loc = len('application/vnd.openstack.orchestration-') accept_version = accept[token_loc:] match = self._match_version_string(accept_version, req) if match: major_version = req.environ['api.major_version'] minor_version = req.environ['api.minor_version'] if (major_version == 1 and minor_version == 0): logger.debug(_("Matched versioned media type. Version: " "%(major_version)d.%(minor_version)d") % {'major_version': major_version, 'minor_version': minor_version}) return None else: logger.debug(_("Unknown version in accept header: " "%(major_version)d.%(minor_version)d..." "returning version choices.") % {'major_version': major_version, 'minor_version': minor_version}) return self.versions_app else: if req.accept not in ('*/*', ''): logger.debug(_("Unknown accept header: %s..." "returning HTTP not found."), req.accept) return webob.exc.HTTPNotFound() return None def _match_version_string(self, subject, req): """ Given a subject string, tries to match a major and/or minor version number. If found, sets the api.major_version and api.minor_version environ variables. Returns True if there was a match, false otherwise. :param subject: The string to check :param req: Webob.Request object """ match = self.version_uri_regex.match(subject) if match: major_version, minor_version = match.groups(0) major_version = int(major_version) minor_version = int(minor_version) req.environ['api.major_version'] = major_version req.environ['api.minor_version'] = minor_version return match is not None heat-2014.1.5/heat/api/middleware/__init__.py0000664000567000056700000000000012540642611021734 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/middleware/fault.py0000664000567000056700000001172012540642614021326 0ustar jenkinsjenkins00000000000000# -*- encoding: utf-8 -*- # # Copyright © 2013 Unitedstack Inc. # # Author: Jianing YANG (jianingy@unitedstack.com) # # 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. """A middleware that turns exceptions into parsable string. Inspired by Cinder's faultwrapper """ import traceback from oslo.config import cfg import webob cfg.CONF.import_opt('debug', 'heat.openstack.common.log') from heat.common import exception from heat.openstack.common import log as logging import heat.openstack.common.rpc.common as rpc_common from heat.common import wsgi logger = logging.getLogger(__name__) class Fault(object): def __init__(self, error): self.error = error @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): if req.content_type == 'application/xml': serializer = wsgi.XMLResponseSerializer() else: serializer = wsgi.JSONResponseSerializer() resp = webob.Response(request=req) default_webob_exc = webob.exc.HTTPInternalServerError() resp.status_code = self.error.get('code', default_webob_exc.code) serializer.default(resp, self.error) return resp class FaultWrapper(wsgi.Middleware): """Replace error body with something the client can parse.""" error_map = { 'AttributeError': webob.exc.HTTPBadRequest, 'ActionInProgress': webob.exc.HTTPConflict, 'ValueError': webob.exc.HTTPBadRequest, 'StackNotFound': webob.exc.HTTPNotFound, 'NotFound': webob.exc.HTTPNotFound, 'ResourceNotFound': webob.exc.HTTPNotFound, 'ResourceTypeNotFound': webob.exc.HTTPNotFound, 'ResourceNotAvailable': webob.exc.HTTPNotFound, 'PhysicalResourceNotFound': webob.exc.HTTPNotFound, 'InvalidTenant': webob.exc.HTTPForbidden, 'Forbidden': webob.exc.HTTPForbidden, 'StackExists': webob.exc.HTTPConflict, 'StackValidationFailed': webob.exc.HTTPBadRequest, 'InvalidTemplateReference': webob.exc.HTTPBadRequest, 'InvalidTemplateVersion': webob.exc.HTTPBadRequest, 'InvalidTemplateSection': webob.exc.HTTPBadRequest, 'UnknownUserParameter': webob.exc.HTTPBadRequest, 'RevertFailed': webob.exc.HTTPInternalServerError, 'StopActionFailed': webob.exc.HTTPInternalServerError, 'ServerBuildFailed': webob.exc.HTTPInternalServerError, 'NotSupported': webob.exc.HTTPBadRequest, 'MissingCredentialError': webob.exc.HTTPBadRequest, 'UserParameterMissing': webob.exc.HTTPBadRequest, 'RequestLimitExceeded': webob.exc.HTTPBadRequest, 'InvalidTemplateParameter': webob.exc.HTTPBadRequest, 'Invalid': webob.exc.HTTPBadRequest, } def _map_exception_to_error(self, class_exception): if class_exception == Exception: return webob.exc.HTTPInternalServerError if class_exception.__name__ not in self.error_map: return self._map_exception_to_error(class_exception.__base__) return self.error_map[class_exception.__name__] def _error(self, ex): trace = None webob_exc = None if isinstance(ex, exception.HTTPExceptionDisguise): # An HTTP exception was disguised so it could make it here # let's remove the disguise and set the original HTTP exception if cfg.CONF.debug: trace = ''.join(traceback.format_tb(ex.tb)) ex = ex.exc webob_exc = ex ex_type = ex.__class__.__name__ if ex_type.endswith(rpc_common._REMOTE_POSTFIX): ex_type = ex_type[:-len(rpc_common._REMOTE_POSTFIX)] full_message = unicode(ex) if full_message.find('\n') > -1: message, msg_trace = full_message.split('\n', 1) else: msg_trace = traceback.format_exc() message = full_message if cfg.CONF.debug and not trace: trace = msg_trace if not webob_exc: webob_exc = self._map_exception_to_error(ex.__class__) error = { 'code': webob_exc.code, 'title': webob_exc.title, 'explanation': webob_exc.explanation, 'error': { 'message': message, 'type': ex_type, 'traceback': trace, } } return error def process_request(self, req): try: return req.get_response(self.application) except Exception as exc: return req.get_response(Fault(self._error(exc))) heat-2014.1.5/heat/api/openstack/0000775000567000056700000000000012540643116017510 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/openstack/versions.py0000664000567000056700000000313012540642614021731 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. """ Controller that returns information on the heat API versions """ import httplib import json import webob.dec class Controller(object): """ A controller that produces information on the heat API versions. """ def __init__(self, conf): self.conf = conf @webob.dec.wsgify def __call__(self, req): """Respond to a request for all OpenStack API versions.""" version_objs = [ { "id": "v1.0", "status": "CURRENT", "links": [ { "rel": "self", "href": self.get_href(req) }] }] body = json.dumps(dict(versions=version_objs)) response = webob.Response(request=req, status=httplib.MULTIPLE_CHOICES, content_type='application/json') response.body = body return response def get_href(self, req): return "%s/v1/" % req.host_url heat-2014.1.5/heat/api/openstack/__init__.py0000664000567000056700000000215412540642614021625 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. from heat.api.middleware.fault import FaultWrapper from heat.api.middleware.ssl import SSLMiddleware from heat.api.middleware.version_negotiation import VersionNegotiationFilter from heat.api.openstack import versions def version_negotiation_filter(app, conf, **local_conf): return VersionNegotiationFilter(versions.Controller, app, conf, **local_conf) def faultwrap_filter(app, conf, **local_conf): return FaultWrapper(app) def sslmiddleware_filter(app, conf, **local_conf): return SSLMiddleware(app) heat-2014.1.5/heat/api/openstack/v1/0000775000567000056700000000000012540643116020036 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/openstack/v1/software_configs.py0000664000567000056700000000467512540642614023770 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. from webob import exc from heat.api.openstack.v1 import util from heat.common import wsgi from heat.rpc import client as rpc_client class SoftwareConfigController(object): """ WSGI controller for Software config in Heat v1 API Implements the API actions """ REQUEST_SCOPE = 'software_configs' def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() def default(self, req, **args): raise exc.HTTPNotFound() @util.policy_enforce def show(self, req, config_id): """ Gets detailed information for a software config """ sc = self.rpc_client.show_software_config( req.context, config_id) return {'software_config': sc} @util.policy_enforce def create(self, req, body): """ Create a new software config """ create_data = { 'name': body.get('name'), 'group': body.get('group'), 'config': body.get('config'), 'inputs': body.get('inputs'), 'outputs': body.get('outputs'), 'options': body.get('options'), } sc = self.rpc_client.create_software_config( req.context, **create_data) return {'software_config': sc} @util.policy_enforce def delete(self, req, config_id): """ Delete an existing software config """ res = self.rpc_client.delete_software_config(req.context, config_id) if res is not None: raise exc.HTTPBadRequest(res['Error']) raise exc.HTTPNoContent() def create_resource(options): """ Software configs resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = wsgi.JSONResponseSerializer() return wsgi.Resource( SoftwareConfigController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/util.py0000664000567000056700000000674312540642614021401 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. from functools import wraps from webob import exc from heat.common import identifier def policy_enforce(handler): ''' Decorator for a handler method that checks the path matches the request context and enforce policy defined in policy.json ''' @wraps(handler) def handle_stack_method(controller, req, tenant_id, **kwargs): if req.context.tenant_id != tenant_id: raise exc.HTTPForbidden() allowed = req.context.policy.enforce(context=req.context, action=handler.__name__, scope=controller.REQUEST_SCOPE) if not allowed: raise exc.HTTPForbidden() return handler(controller, req, **kwargs) return handle_stack_method def identified_stack(handler): ''' Decorator for a handler method that passes a stack identifier in place of the various path components. ''' @policy_enforce @wraps(handler) def handle_stack_method(controller, req, stack_name, stack_id, **kwargs): stack_identity = identifier.HeatIdentifier(req.context.tenant_id, stack_name, stack_id) return handler(controller, req, dict(stack_identity), **kwargs) return handle_stack_method def make_url(req, identity): '''Return the URL for the supplied identity dictionary.''' try: stack_identity = identifier.HeatIdentifier(**identity) except ValueError: err_reason = _('Invalid Stack address') raise exc.HTTPInternalServerError(err_reason) return req.relative_url(stack_identity.url_path(), True) def make_link(req, identity, relationship='self'): '''Return a link structure for the supplied identity dictionary.''' return {'href': make_url(req, identity), 'rel': relationship} def get_allowed_params(params, whitelist): '''Extract from ``params`` all entries listed in ``whitelist`` The returning dict will contain an entry for a key if, and only if, there's an entry in ``whitelist`` for that key and at least one entry in ``params``. If ``params`` contains multiple entries for the same key, it will yield an array of values: ``{key: [v1, v2,...]}`` :param params: a NestedMultiDict from webob.Request.params :param whitelist: an array of strings to whitelist :returns: a dict with {key: value} pairs ''' allowed_params = {} for key, get_type in whitelist.iteritems(): value = None if get_type == 'single': value = params.get(key) elif get_type == 'multi': value = params.getall(key) elif get_type == 'mixed': value = params.getall(key) if isinstance(value, list) and len(value) == 1: value = value.pop() if value: allowed_params[key] = value return allowed_params heat-2014.1.5/heat/api/openstack/v1/resources.py0000664000567000056700000001010612540642614022422 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. import itertools from heat.api.openstack.v1 import util from heat.common import identifier from heat.common import wsgi from heat.rpc import api as engine_api from heat.rpc import client as rpc_client def format_resource(req, res, keys=[]): include_key = lambda k: k in keys if keys else True def transform(key, value): if not include_key(key): return if key == engine_api.RES_ID: identity = identifier.ResourceIdentifier(**value) yield ('links', [util.make_link(req, identity), util.make_link(req, identity.stack(), 'stack')]) elif (key == engine_api.RES_STACK_NAME or key == engine_api.RES_STACK_ID or key == engine_api.RES_ACTION): return elif (key == engine_api.RES_METADATA): return elif (key == engine_api.RES_STATUS and engine_api.RES_ACTION in res): # To avoid breaking API compatibility, we join RES_ACTION # and RES_STATUS, so the API format doesn't expose the # internal split of state into action/status yield (key, '_'.join((res[engine_api.RES_ACTION], value))) elif (key == engine_api.RES_NAME): yield ('logical_resource_id', value) yield (key, value) else: yield (key, value) return dict(itertools.chain.from_iterable( transform(k, v) for k, v in res.items())) class ResourceController(object): """ WSGI controller for Resources in Heat v1 API Implements the API actions """ # Define request scope (must match what is in policy.json) REQUEST_SCOPE = 'resource' def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() @util.identified_stack def index(self, req, identity): """ Lists summary information for all resources """ res_list = self.rpc_client.list_stack_resources(req.context, identity) return {'resources': [format_resource(req, res) for res in res_list]} @util.identified_stack def show(self, req, identity, resource_name): """ Gets detailed information for a resource """ res = self.rpc_client.describe_stack_resource(req.context, identity, resource_name) return {'resource': format_resource(req, res)} @util.identified_stack def metadata(self, req, identity, resource_name): """ Gets metadata information for a resource """ res = self.rpc_client.describe_stack_resource(req.context, identity, resource_name) return {engine_api.RES_METADATA: res[engine_api.RES_METADATA]} @util.identified_stack def signal(self, req, identity, resource_name, body=None): self.rpc_client.resource_signal(req.context, stack_identity=identity, resource_name=resource_name, details=body) def create_resource(options): """ Resources resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = wsgi.JSONResponseSerializer() return wsgi.Resource(ResourceController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/build_info.py0000664000567000056700000000317712540642614022534 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. from oslo.config import cfg from heat.api.openstack.v1 import util from heat.common import wsgi from heat.rpc import client as rpc_client class BuildInfoController(object): """ WSGI controller for BuildInfo in Heat v1 API Returns build information for current app """ # Define request scope (must match what is in policy.json) REQUEST_SCOPE = 'build_info' def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() @util.policy_enforce def build_info(self, req): engine_revision = self.rpc_client.get_revision(req.context) build_info = { 'api': {'revision': cfg.CONF.revision['heat_revision']}, 'engine': {'revision': engine_revision} } return build_info def create_resource(options): """ BuildInfo factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = wsgi.JSONResponseSerializer() return wsgi.Resource(BuildInfoController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/views/0000775000567000056700000000000012540643116021173 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/openstack/v1/views/views_common.py0000664000567000056700000000245712540642614024264 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. from heat.openstack.common.py3kcompat import urlutils def get_collection_links(request, items): """Retrieve 'next' link, if applicable.""" links = [] try: limit = int(request.params.get("limit") or 0) except ValueError: limit = 0 if limit > 0 and limit == len(items): last_item = items[-1] last_item_id = last_item["id"] links.append({ "rel": "next", "href": _get_next_link(request, last_item_id) }) return links def _get_next_link(request, marker): """Return href string with proper limit and marker params.""" params = request.params.copy() params['marker'] = marker return "%s?%s" % (request.path_url, urlutils.urlencode(params)) heat-2014.1.5/heat/api/openstack/v1/views/__init__.py0000664000567000056700000000000012540642611023271 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/openstack/v1/views/stacks_view.py0000664000567000056700000000511212540642614024070 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. import itertools from heat.api.openstack.v1 import util from heat.api.openstack.v1.views import views_common from heat.rpc import api as engine_api _collection_name = 'stacks' basic_keys = (engine_api.STACK_ID, engine_api.STACK_NAME, engine_api.STACK_DESCRIPTION, engine_api.STACK_STATUS, engine_api.STACK_STATUS_DATA, engine_api.STACK_CREATION_TIME, engine_api.STACK_DELETION_TIME, engine_api.STACK_UPDATED_TIME) def format_stack(req, stack, keys=None, tenant_safe=True): def transform(key, value): if keys and key not in keys: return if key == engine_api.STACK_ID: yield ('id', value['stack_id']) yield ('links', [util.make_link(req, value)]) if not tenant_safe: yield ('project', value['tenant']) elif key == engine_api.STACK_ACTION: return elif (key == engine_api.STACK_STATUS and engine_api.STACK_ACTION in stack): # To avoid breaking API compatibility, we join RES_ACTION # and RES_STATUS, so the API format doesn't expose the # internal split of state into action/status yield (key, '_'.join((stack[engine_api.STACK_ACTION], value))) else: # TODO(zaneb): ensure parameters can be formatted for XML #elif key == engine_api.STACK_PARAMETERS: # return key, json.dumps(value) yield (key, value) return dict(itertools.chain.from_iterable( transform(k, v) for k, v in stack.items())) def collection(req, stacks, count=None, tenant_safe=True): keys = basic_keys formatted_stacks = [format_stack(req, s, keys, tenant_safe) for s in stacks] result = {'stacks': formatted_stacks} links = views_common.get_collection_links(req, formatted_stacks) if links: result['links'] = links if count is not None: result['count'] = count return result heat-2014.1.5/heat/api/openstack/v1/software_deployments.py0000664000567000056700000000742012540642614024672 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. from webob import exc from heat.api.openstack.v1 import util from heat.common import wsgi from heat.rpc import client as rpc_client class SoftwareDeploymentController(object): """ WSGI controller for Software deployments in Heat v1 API Implements the API actions """ REQUEST_SCOPE = 'software_deployments' def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() def default(self, req, **args): raise exc.HTTPNotFound() @util.policy_enforce def index(self, req): """ List software deployments. """ whitelist = { 'server_id': 'single', } params = util.get_allowed_params(req.params, whitelist) sds = self.rpc_client.list_software_deployments(req.context, **params) return {'software_deployments': sds} @util.policy_enforce def metadata(self, req, server_id): """ List software deployments grouped by the group name for the requested server. """ sds = self.rpc_client.metadata_software_deployments( req.context, server_id=server_id) return {'metadata': sds} @util.policy_enforce def show(self, req, deployment_id): """ Gets detailed information for a software deployment """ sd = self.rpc_client.show_software_deployment(req.context, deployment_id) return {'software_deployment': sd} @util.policy_enforce def create(self, req, body): """ Create a new software deployment """ create_data = dict((k, body.get(k)) for k in ( 'config_id', 'server_id', 'input_values', 'action', 'status', 'status_reason', 'stack_user_project_id')) sd = self.rpc_client.create_software_deployment(req.context, **create_data) return {'software_deployment': sd} @util.policy_enforce def update(self, req, deployment_id, body): """ Update an existing software deployment """ update_data = dict((k, body.get(k)) for k in ( 'config_id', 'input_values', 'output_values', 'action', 'status', 'status_reason')) sd = self.rpc_client.update_software_deployment(req.context, deployment_id, **update_data) return {'software_deployment': sd} @util.policy_enforce def delete(self, req, deployment_id): """ Delete an existing software deployment """ res = self.rpc_client.delete_software_deployment(req.context, deployment_id) if res is not None: raise exc.HTTPBadRequest(res['Error']) raise exc.HTTPNoContent() def create_resource(options): """ Software deployments resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = wsgi.JSONResponseSerializer() return wsgi.Resource( SoftwareDeploymentController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/actions.py0000664000567000056700000000425312540642614022056 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. from webob import exc from heat.api.openstack.v1 import util from heat.common import wsgi from heat.rpc import client as rpc_client class ActionController(object): """ WSGI controller for Actions in Heat v1 API Implements the API for stack actions """ # Define request scope (must match what is in policy.json) REQUEST_SCOPE = 'actions' ACTIONS = (SUSPEND, RESUME) = ('suspend', 'resume') def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() @util.identified_stack def action(self, req, identity, body={}): """ Performs a specified action on a stack, the body is expecting to contain exactly one item whose key specifies the action """ if len(body) < 1: raise exc.HTTPBadRequest(_("No action specified")) if len(body) > 1: raise exc.HTTPBadRequest(_("Multiple actions specified")) ac = body.keys()[0] if ac not in self.ACTIONS: raise exc.HTTPBadRequest(_("Invalid action %s specified") % ac) if ac == self.SUSPEND: self.rpc_client.stack_suspend(req.context, identity) elif ac == self.RESUME: self.rpc_client.stack_resume(req.context, identity) else: raise exc.HTTPInternalServerError(_("Unexpected action %s") % ac) def create_resource(options): """ Actions action factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = wsgi.JSONResponseSerializer() return wsgi.Resource(ActionController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/stacks.py0000664000567000056700000003163412540642614021711 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. """ Stack endpoint for Heat v1 ReST API. """ from webob import exc from heat.api.openstack.v1 import util from heat.api.openstack.v1.views import stacks_view from heat.common import environment_format from heat.common import identifier from heat.common import template_format from heat.common import urlfetch from heat.common import wsgi from heat.openstack.common import log as logging from heat.rpc import api as engine_api from heat.rpc import client as rpc_client logger = logging.getLogger(__name__) class InstantiationData(object): """ The data accompanying a PUT or POST request to create or update a stack. """ PARAMS = ( PARAM_STACK_NAME, PARAM_TEMPLATE, PARAM_TEMPLATE_URL, PARAM_USER_PARAMS, PARAM_ENVIRONMENT, PARAM_FILES, ) = ( 'stack_name', 'template', 'template_url', 'parameters', 'environment', 'files', ) def __init__(self, data): """Initialise from the request object.""" self.data = data @staticmethod def format_parse(data, data_type): """ Parse the supplied data as JSON or YAML, raising the appropriate exception if it is in the wrong format. """ try: if data_type == 'Environment': return environment_format.parse(data) else: return template_format.parse(data) except ValueError as parse_ex: mdict = {'type': data_type, 'error': parse_ex} msg = _("%(type)s not in valid format: %(error)s") % mdict raise exc.HTTPBadRequest(msg) def stack_name(self): """ Return the stack name. """ if self.PARAM_STACK_NAME not in self.data: raise exc.HTTPBadRequest(_("No stack name specified")) return self.data[self.PARAM_STACK_NAME] def template(self): """ Get template file contents, either inline or from a URL, in JSON or YAML format. """ if self.PARAM_TEMPLATE in self.data: template_data = self.data[self.PARAM_TEMPLATE] if isinstance(template_data, dict): return template_data elif self.PARAM_TEMPLATE_URL in self.data: url = self.data[self.PARAM_TEMPLATE_URL] logger.debug('TemplateUrl %s' % url) try: template_data = urlfetch.get(url) except IOError as ex: err_reason = _('Could not retrieve template: %s') % str(ex) raise exc.HTTPBadRequest(err_reason) else: raise exc.HTTPBadRequest(_("No template specified")) return self.format_parse(template_data, 'Template') def environment(self): """ Get the user-supplied environment for the stack in YAML format. If the user supplied Parameters then merge these into the environment global options. """ env = {} if self.PARAM_ENVIRONMENT in self.data: env_data = self.data[self.PARAM_ENVIRONMENT] if isinstance(env_data, dict): env = env_data else: env = self.format_parse(env_data, 'Environment') environment_format.default_for_missing(env) parameters = self.data.get(self.PARAM_USER_PARAMS, {}) env[self.PARAM_USER_PARAMS].update(parameters) return env def files(self): return self.data.get(self.PARAM_FILES, {}) def args(self): """ Get any additional arguments supplied by the user. """ params = self.data.items() return dict((k, v) for k, v in params if k not in self.PARAMS) class StackController(object): """ WSGI controller for stacks resource in Heat v1 API Implements the API actions """ # Define request scope (must match what is in policy.json) REQUEST_SCOPE = 'stacks' def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() def default(self, req, **args): raise exc.HTTPNotFound() def _index(self, req, tenant_safe=True): filter_whitelist = { 'status': 'mixed', 'name': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if req.params.get('with_count'): try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe) except AttributeError as exc: logger.warning("Old Engine Version: %s" % str(exc)) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe) @util.policy_enforce def global_index(self, req): return self._index(req, tenant_safe=False) @util.policy_enforce def index(self, req): """ Lists summary information for all stacks """ global_tenant = bool(req.params.get('global_tenant', False)) if global_tenant: return self.global_index(req, req.context.tenant_id) return self._index(req) @util.policy_enforce def detail(self, req): """ Lists detailed information for all stacks """ stacks = self.rpc_client.list_stacks(req.context) return {'stacks': [stacks_view.format_stack(req, s) for s in stacks]} @util.policy_enforce def preview(self, req, body): """ Preview the outcome of a template and its params """ data = InstantiationData(body) result = self.rpc_client.preview_stack(req.context, data.stack_name(), data.template(), data.environment(), data.files(), data.args()) formatted_stack = stacks_view.format_stack(req, result) return {'stack': formatted_stack} @util.policy_enforce def create(self, req, body): """ Create a new stack """ data = InstantiationData(body) result = self.rpc_client.create_stack(req.context, data.stack_name(), data.template(), data.environment(), data.files(), data.args()) formatted_stack = stacks_view.format_stack( req, {engine_api.STACK_ID: result} ) return {'stack': formatted_stack} @util.policy_enforce def lookup(self, req, stack_name, path='', body=None): """ Redirect to the canonical URL for a stack """ try: identity = dict(identifier.HeatIdentifier.from_arn(stack_name)) except ValueError: identity = self.rpc_client.identify_stack(req.context, stack_name) location = util.make_url(req, identity) if path: location = '/'.join([location, path]) raise exc.HTTPFound(location=location) @util.identified_stack def show(self, req, identity): """ Gets detailed information for a stack """ stack_list = self.rpc_client.show_stack(req.context, identity) if not stack_list: raise exc.HTTPInternalServerError() stack = stack_list[0] return {'stack': stacks_view.format_stack(req, stack)} @util.identified_stack def template(self, req, identity): """ Get the template body for an existing stack """ templ = self.rpc_client.get_template(req.context, identity) if templ is None: raise exc.HTTPNotFound() # TODO(zaneb): always set Content-type to application/json return templ @util.identified_stack def update(self, req, identity, body): """ Update an existing stack with a new template and/or parameters """ data = InstantiationData(body) self.rpc_client.update_stack(req.context, identity, data.template(), data.environment(), data.files(), data.args()) raise exc.HTTPAccepted() @util.identified_stack def delete(self, req, identity): """ Delete the specified stack """ res = self.rpc_client.delete_stack(req.context, identity, cast=False) if res is not None: raise exc.HTTPBadRequest(res['Error']) raise exc.HTTPNoContent() @util.identified_stack def abandon(self, req, identity): """ Abandons specified stack by deleting the stack and it's resources from the database, but underlying resources will not be deleted. """ return self.rpc_client.abandon_stack(req.context, identity) @util.policy_enforce def validate_template(self, req, body): """ Implements the ValidateTemplate API action Validates the specified template """ data = InstantiationData(body) result = self.rpc_client.validate_template(req.context, data.template(), data.environment()) if 'Error' in result: raise exc.HTTPBadRequest(result['Error']) return result @util.policy_enforce def list_resource_types(self, req): """ Returns a list of valid resource types that may be used in a template. """ support_status = req.params.get('support_status') return { 'resource_types': self.rpc_client.list_resource_types(req.context, support_status)} @util.policy_enforce def resource_schema(self, req, type_name): """ Returns the schema of the given resource type. """ return self.rpc_client.resource_schema(req.context, type_name) @util.policy_enforce def generate_template(self, req, type_name): """ Generates a template based on the specified type. """ return self.rpc_client.generate_template(req.context, type_name) class StackSerializer(wsgi.JSONResponseSerializer): """Handles serialization of specific controller method responses.""" def _populate_response_header(self, response, location, status): response.status = status response.headers['Location'] = location.encode('utf-8') response.headers['Content-Type'] = 'application/json' return response def create(self, response, result): self._populate_response_header(response, result['stack']['links'][0]['href'], 201) response.body = self.to_json(result) return response def create_resource(options): """ Stacks resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = StackSerializer() return wsgi.Resource(StackController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/events.py0000664000567000056700000001071712540642614021724 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. import itertools from webob import exc from heat.api.openstack.v1 import util from heat.common import identifier from heat.common import wsgi from heat.rpc import api as engine_api from heat.rpc import client as rpc_client summary_keys = [ engine_api.EVENT_ID, engine_api.EVENT_TIMESTAMP, engine_api.EVENT_RES_NAME, engine_api.EVENT_RES_STATUS, engine_api.EVENT_RES_STATUS_DATA, engine_api.EVENT_RES_PHYSICAL_ID, ] def format_event(req, event, keys=None): include_key = lambda k: k in keys if keys else True def transform(key, value): if not include_key(key): return if key == engine_api.EVENT_ID: identity = identifier.EventIdentifier(**value) yield ('id', identity.event_id) yield ('links', [util.make_link(req, identity), util.make_link(req, identity.resource(), 'resource'), util.make_link(req, identity.stack(), 'stack')]) elif key in (engine_api.EVENT_STACK_ID, engine_api.EVENT_STACK_NAME, engine_api.EVENT_RES_ACTION): return elif (key == engine_api.EVENT_RES_STATUS and engine_api.EVENT_RES_ACTION in event): # To avoid breaking API compatibility, we join RES_ACTION # and RES_STATUS, so the API format doesn't expose the # internal split of state into action/status yield (key, '_'.join((event[engine_api.EVENT_RES_ACTION], value))) elif (key == engine_api.RES_NAME): yield ('logical_resource_id', value) yield (key, value) else: yield (key, value) return dict(itertools.chain.from_iterable( transform(k, v) for k, v in event.items())) class EventController(object): """ WSGI controller for Events in Heat v1 API Implements the API actions """ # Define request scope (must match what is in policy.json) REQUEST_SCOPE = 'events' def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() def _event_list(self, req, identity, filter_func=lambda e: True, detail=False): events = self.rpc_client.list_events(req.context, identity) keys = None if detail else summary_keys return [format_event(req, e, keys) for e in events if filter_func(e)] @util.identified_stack def index(self, req, identity, resource_name=None): """ Lists summary information for all events """ if resource_name is None: events = self._event_list(req, identity) else: res_match = lambda e: e[engine_api.EVENT_RES_NAME] == resource_name events = self._event_list(req, identity, res_match) if not events: msg = _('No events found for resource %s') % resource_name raise exc.HTTPNotFound(msg) return {'events': events} @util.identified_stack def show(self, req, identity, resource_name, event_id): """ Gets detailed information for an event """ def event_match(ev): identity = identifier.EventIdentifier(**ev[engine_api.EVENT_ID]) return (ev[engine_api.EVENT_RES_NAME] == resource_name and identity.event_id == event_id) events = self._event_list(req, identity, event_match, True) if not events: raise exc.HTTPNotFound(_('No event %s found') % event_id) return {'event': events[0]} def create_resource(options): """ Events resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() serializer = wsgi.JSONResponseSerializer() return wsgi.Resource(EventController(options), deserializer, serializer) heat-2014.1.5/heat/api/openstack/v1/__init__.py0000664000567000056700000002537012540642614022160 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. import routes from heat.api.openstack.v1 import actions from heat.api.openstack.v1 import build_info from heat.api.openstack.v1 import events from heat.api.openstack.v1 import resources from heat.api.openstack.v1 import software_configs from heat.api.openstack.v1 import software_deployments from heat.api.openstack.v1 import stacks from heat.common import wsgi from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class API(wsgi.Router): """ WSGI router for Heat v1 ReST API requests. """ def __init__(self, conf, **local_conf): self.conf = conf mapper = routes.Mapper() # Stacks stacks_resource = stacks.create_resource(conf) with mapper.submapper(controller=stacks_resource, path_prefix="/{tenant_id}") as stack_mapper: # Template handling stack_mapper.connect("template_validate", "/validate", action="validate_template", conditions={'method': 'POST'}) stack_mapper.connect("resource_types", "/resource_types", action="list_resource_types", conditions={'method': 'GET'}) stack_mapper.connect("resource_schema", "/resource_types/{type_name}", action="resource_schema", conditions={'method': 'GET'}) stack_mapper.connect("generate_template", "/resource_types/{type_name}/template", action="generate_template", conditions={'method': 'GET'}) # Stack collection stack_mapper.connect("stack_index", "/stacks", action="index", conditions={'method': 'GET'}) stack_mapper.connect("stack_create", "/stacks", action="create", conditions={'method': 'POST'}) stack_mapper.connect("stack_preview", "/stacks/preview", action="preview", conditions={'method': 'POST'}) stack_mapper.connect("stack_detail", "/stacks/detail", action="detail", conditions={'method': 'GET'}) # Stack data stack_mapper.connect("stack_lookup", "/stacks/{stack_name}", action="lookup") # \x3A matches on a colon. # Routes treats : specially in its regexp stack_mapper.connect("stack_lookup", r"/stacks/{stack_name:arn\x3A.*}", action="lookup") subpaths = ['resources', 'events', 'template', 'actions'] path = "{path:%s}" % '|'.join(subpaths) stack_mapper.connect("stack_lookup_subpath", "/stacks/{stack_name}/" + path, action="lookup", conditions={'method': 'GET'}) stack_mapper.connect("stack_lookup_subpath_post", "/stacks/{stack_name}/" + path, action="lookup", conditions={'method': 'POST'}) stack_mapper.connect("stack_show", "/stacks/{stack_name}/{stack_id}", action="show", conditions={'method': 'GET'}) stack_mapper.connect("stack_template", "/stacks/{stack_name}/{stack_id}/template", action="template", conditions={'method': 'GET'}) # Stack update/delete stack_mapper.connect("stack_update", "/stacks/{stack_name}/{stack_id}", action="update", conditions={'method': 'PUT'}) stack_mapper.connect("stack_delete", "/stacks/{stack_name}/{stack_id}", action="delete", conditions={'method': 'DELETE'}) # Stack abandon stack_mapper.connect("stack_abandon", "/stacks/{stack_name}/{stack_id}/abandon", action="abandon", conditions={'method': 'DELETE'}) # Resources resources_resource = resources.create_resource(conf) stack_path = "/{tenant_id}/stacks/{stack_name}/{stack_id}" with mapper.submapper(controller=resources_resource, path_prefix=stack_path) as res_mapper: # Resource collection res_mapper.connect("resource_index", "/resources", action="index", conditions={'method': 'GET'}) # Resource data res_mapper.connect("resource_show", "/resources/{resource_name}", action="show", conditions={'method': 'GET'}) res_mapper.connect("resource_metadata_show", "/resources/{resource_name}/metadata", action="metadata", conditions={'method': 'GET'}) res_mapper.connect("resource_signal", "/resources/{resource_name}/signal", action="signal", conditions={'method': 'POST'}) # Events events_resource = events.create_resource(conf) with mapper.submapper(controller=events_resource, path_prefix=stack_path) as ev_mapper: # Stack event collection ev_mapper.connect("event_index_stack", "/events", action="index", conditions={'method': 'GET'}) # Resource event collection ev_mapper.connect("event_index_resource", "/resources/{resource_name}/events", action="index", conditions={'method': 'GET'}) # Event data ev_mapper.connect("event_show", "/resources/{resource_name}/events/{event_id}", action="show", conditions={'method': 'GET'}) # Actions actions_resource = actions.create_resource(conf) with mapper.submapper(controller=actions_resource, path_prefix=stack_path) as ac_mapper: ac_mapper.connect("action_stack", "/actions", action="action", conditions={'method': 'POST'}) # Info info_resource = build_info.create_resource(conf) with mapper.submapper(controller=info_resource, path_prefix="/{tenant_id}") as info_mapper: info_mapper.connect('build_info', '/build_info', action='build_info', conditions={'method': 'GET'}) # Software configs software_config_resource = software_configs.create_resource(conf) with mapper.submapper( controller=software_config_resource, path_prefix="/{tenant_id}/software_configs" ) as sc_mapper: sc_mapper.connect("software_config_create", "", action="create", conditions={'method': 'POST'}) sc_mapper.connect("software_config_show", "/{config_id}", action="show", conditions={'method': 'GET'}) sc_mapper.connect("software_config_delete", "/{config_id}", action="delete", conditions={'method': 'DELETE'}) # Software deployments sd_resource = software_deployments.create_resource(conf) with mapper.submapper( controller=sd_resource, path_prefix='/{tenant_id}/software_deployments' ) as sa_mapper: sa_mapper.connect("software_deployment_index", "", action="index", conditions={'method': 'GET'}) sa_mapper.connect("software_deployment_metadata", "/metadata/{server_id}", action="metadata", conditions={'method': 'GET'}) sa_mapper.connect("software_deployment_create", "", action="create", conditions={'method': 'POST'}) sa_mapper.connect("software_deployment_show", "/{deployment_id}", action="show", conditions={'method': 'GET'}) sa_mapper.connect("software_deployment_update", "/{deployment_id}", action="update", conditions={'method': 'PUT'}) sa_mapper.connect("software_deployment_delete", "/{deployment_id}", action="delete", conditions={'method': 'DELETE'}) super(API, self).__init__(mapper) heat-2014.1.5/heat/api/cfn/0000775000567000056700000000000012540643116016267 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/cfn/versions.py0000664000567000056700000000313012540642614020510 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. """ Controller that returns information on the heat API versions """ import httplib import json import webob.dec class Controller(object): """ A controller that produces information on the heat API versions. """ def __init__(self, conf): self.conf = conf @webob.dec.wsgify def __call__(self, req): """Respond to a request for all OpenStack API versions.""" version_objs = [ { "id": "v1.0", "status": "CURRENT", "links": [ { "rel": "self", "href": self.get_href(req) }] }] body = json.dumps(dict(versions=version_objs)) response = webob.Response(request=req, status=httplib.MULTIPLE_CHOICES, content_type='application/json') response.body = body return response def get_href(self, req): return "%s/v1/" % req.host_url heat-2014.1.5/heat/api/cfn/__init__.py0000664000567000056700000000165512540642614020411 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. from heat.api.cfn import versions from heat.api.middleware.version_negotiation import VersionNegotiationFilter from heat.openstack.common import gettextutils gettextutils.install('heat') def version_negotiation_filter(app, conf, **local_conf): return VersionNegotiationFilter(versions.Controller, app, conf, **local_conf) heat-2014.1.5/heat/api/cfn/v1/0000775000567000056700000000000012540643116016615 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/cfn/v1/stacks.py0000664000567000056700000006155112540642614020471 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. """ Stack endpoint for Heat CloudFormation v1 API. """ import json import socket from heat.api.aws import exception from heat.api.aws import utils as api_utils from heat.common import exception as heat_exception from heat.common import identifier from heat.common import policy from heat.common import template_format from heat.common import urlfetch from heat.common import wsgi from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.rpc import api as engine_api from heat.rpc import client as rpc_client logger = logging.getLogger(__name__) class StackController(object): """ WSGI controller for stacks resource in Heat CloudFormation v1 API Implements the API actions """ def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() self.policy = policy.Enforcer(scope='cloudformation') def _enforce(self, req, action): """Authorize an action against the policy.json.""" try: self.policy.enforce(req.context, action) except heat_exception.Forbidden: msg = _('Action %s not allowed for user') % action raise exception.HeatAccessDeniedError(msg) except Exception: # We expect policy.enforce to either pass or raise Forbidden # however, if anything else happens, we want to raise # HeatInternalFailureError, failure to do this results in # the user getting a big stacktrace spew as an API response msg = _('Error authorizing action %s') % action raise exception.HeatInternalFailureError(msg) @staticmethod def _id_format(resp): """ Format the StackId field in the response as an ARN, and process other IDs into the correct format. """ if 'StackId' in resp: identity = identifier.HeatIdentifier(**resp['StackId']) resp['StackId'] = identity.arn() if 'EventId' in resp: identity = identifier.EventIdentifier(**resp['EventId']) resp['EventId'] = identity.event_id return resp @staticmethod def _extract_user_params(params): """ Extract a dictionary of user input parameters for the stack In the AWS API parameters, each user parameter appears as two key-value pairs with keys of the form below:: Parameters.member.1.ParameterKey Parameters.member.1.ParameterValue """ return api_utils.extract_param_pairs(params, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') def _get_identity(self, con, stack_name): """ Generate a stack identifier from the given stack name or ARN. In the case of a stack name, the identifier will be looked up in the engine over RPC. """ try: return dict(identifier.HeatIdentifier.from_arn(stack_name)) except ValueError: return self.rpc_client.identify_stack(con, stack_name) def list(self, req): """ Implements ListStacks API action Lists summary information for all stacks """ self._enforce(req, 'ListStacks') def format_stack_summary(s): """ Reformat engine output into the AWS "StackSummary" format """ # Map the engine-api format to the AWS StackSummary datatype keymap = { engine_api.STACK_CREATION_TIME: 'CreationTime', engine_api.STACK_UPDATED_TIME: 'LastUpdatedTime', engine_api.STACK_ID: 'StackId', engine_api.STACK_NAME: 'StackName', engine_api.STACK_STATUS_DATA: 'StackStatusReason', engine_api.STACK_TMPL_DESCRIPTION: 'TemplateDescription', } result = api_utils.reformat_dict_keys(keymap, s) action = s[engine_api.STACK_ACTION] status = s[engine_api.STACK_STATUS] result['StackStatus'] = '_'.join((action, status)) # AWS docs indicate DeletionTime is omitted for current stacks # This is still TODO(unknown) in the engine, we don't keep data for # stacks after they are deleted if engine_api.STACK_DELETION_TIME in s: result['DeletionTime'] = s[engine_api.STACK_DELETION_TIME] return self._id_format(result) con = req.context try: stack_list = self.rpc_client.list_stacks(con) except Exception as ex: return exception.map_remote_error(ex) res = {'StackSummaries': [format_stack_summary(s) for s in stack_list]} return api_utils.format_response('ListStacks', res) def describe(self, req): """ Implements DescribeStacks API action Gets detailed information for a stack (or all stacks) """ self._enforce(req, 'DescribeStacks') def format_stack_outputs(o): keymap = { engine_api.OUTPUT_DESCRIPTION: 'Description', engine_api.OUTPUT_KEY: 'OutputKey', engine_api.OUTPUT_VALUE: 'OutputValue', } def replacecolon(d): return dict(map(lambda (k, v): (k.replace(':', '.'), v), d.items())) def transform(attrs): """ Recursively replace all : with . in dict keys so that they are not interpreted as xml namespaces. """ new = replacecolon(attrs) for key, value in new.items(): if isinstance(value, dict): new[key] = transform(value) return new return api_utils.reformat_dict_keys(keymap, transform(o)) def format_stack(s): """ Reformat engine output into the AWS "StackSummary" format """ keymap = { engine_api.STACK_CAPABILITIES: 'Capabilities', engine_api.STACK_CREATION_TIME: 'CreationTime', engine_api.STACK_DESCRIPTION: 'Description', engine_api.STACK_DISABLE_ROLLBACK: 'DisableRollback', engine_api.STACK_NOTIFICATION_TOPICS: 'NotificationARNs', engine_api.STACK_PARAMETERS: 'Parameters', engine_api.STACK_ID: 'StackId', engine_api.STACK_NAME: 'StackName', engine_api.STACK_STATUS_DATA: 'StackStatusReason', engine_api.STACK_TIMEOUT: 'TimeoutInMinutes', } if s[engine_api.STACK_UPDATED_TIME] is not None: keymap[engine_api.STACK_UPDATED_TIME] = 'LastUpdatedTime' result = api_utils.reformat_dict_keys(keymap, s) action = s[engine_api.STACK_ACTION] status = s[engine_api.STACK_STATUS] result['StackStatus'] = '_'.join((action, status)) # Reformat outputs, these are handled separately as they are # only present in the engine output for a completely created # stack result['Outputs'] = [] if engine_api.STACK_OUTPUTS in s: for o in s[engine_api.STACK_OUTPUTS]: result['Outputs'].append(format_stack_outputs(o)) # Reformat Parameters dict-of-dict into AWS API format # This is a list-of-dict with nasty "ParameterKey" : key # "ParameterValue" : value format. result['Parameters'] = [{'ParameterKey': k, 'ParameterValue': v} for (k, v) in result['Parameters'].items()] return self._id_format(result) con = req.context # If no StackName parameter is passed, we pass None into the engine # this returns results for all stacks (visible to this user), which # is the behavior described in the AWS DescribeStacks API docs try: if 'StackName' in req.params: identity = self._get_identity(con, req.params['StackName']) else: identity = None stack_list = self.rpc_client.show_stack(con, identity) except Exception as ex: return exception.map_remote_error(ex) res = {'Stacks': [format_stack(s) for s in stack_list]} return api_utils.format_response('DescribeStacks', res) def _get_template(self, req): """ Get template file contents, either from local file or URL """ if 'TemplateBody' in req.params: logger.debug('TemplateBody ...') return req.params['TemplateBody'] elif 'TemplateUrl' in req.params: url = req.params['TemplateUrl'] logger.debug('TemplateUrl %s' % url) try: return urlfetch.get(url) except IOError as exc: msg = _('Failed to fetch template: %s') % str(exc) raise exception.HeatInvalidParameterValueError(detail=msg) return None CREATE_OR_UPDATE_ACTION = ( CREATE_STACK, UPDATE_STACK, ) = ( "CreateStack", "UpdateStack", ) def create(self, req): self._enforce(req, 'CreateStack') return self.create_or_update(req, self.CREATE_STACK) def update(self, req): self._enforce(req, 'UpdateStack') return self.create_or_update(req, self.UPDATE_STACK) def create_or_update(self, req, action=None): """ Implements CreateStack and UpdateStack API actions. Create or update stack as defined in template file. """ def extract_args(params): """ Extract request parameters/arguments and reformat them to match the engine API. FIXME: we currently only support a subset of the AWS defined parameters (both here and in the engine) """ # TODO(shardy) : Capabilities, NotificationARNs keymap = {'TimeoutInMinutes': engine_api.PARAM_TIMEOUT, 'DisableRollback': engine_api.PARAM_DISABLE_ROLLBACK} if 'DisableRollback' in params and 'OnFailure' in params: msg = _('DisableRollback and OnFailure ' 'may not be used together') raise exception.HeatInvalidParameterCombinationError( detail=msg) result = {} for k in keymap: if k in params: result[keymap[k]] = params[k] if 'OnFailure' in params: value = params['OnFailure'] if value == 'DO_NOTHING': result[engine_api.PARAM_DISABLE_ROLLBACK] = 'true' elif value in ('ROLLBACK', 'DELETE'): result[engine_api.PARAM_DISABLE_ROLLBACK] = 'false' return result if action not in self.CREATE_OR_UPDATE_ACTION: msg = _("Unexpected action %(action)s") % ({'action': action}) # This should not happen, so return HeatInternalFailureError return exception.HeatInternalFailureError(detail=msg) engine_action = {self.CREATE_STACK: self.rpc_client.create_stack, self.UPDATE_STACK: self.rpc_client.update_stack} con = req.context # Extract the stack input parameters stack_parms = self._extract_user_params(req.params) # Extract any additional arguments ("Request Parameters") create_args = extract_args(req.params) try: templ = self._get_template(req) except socket.gaierror: msg = _('Invalid Template URL') return exception.HeatInvalidParameterValueError(detail=msg) if templ is None: msg = _("TemplateBody or TemplateUrl were not given.") return exception.HeatMissingParameterError(detail=msg) try: stack = template_format.parse(templ) except ValueError: msg = _("The Template must be a JSON or YAML document.") return exception.HeatInvalidParameterValueError(detail=msg) args = {'template': stack, 'params': stack_parms, 'files': {}, 'args': create_args} try: stack_name = req.params['StackName'] if action == self.CREATE_STACK: args['stack_name'] = stack_name else: args['stack_identity'] = self._get_identity(con, stack_name) result = engine_action[action](con, **args) except Exception as ex: return exception.map_remote_error(ex) try: identity = identifier.HeatIdentifier(**result) except (ValueError, TypeError): response = result else: response = {'StackId': identity.arn()} return api_utils.format_response(action, response) def get_template(self, req): """ Implements the GetTemplate API action. Get the template body for an existing stack. """ self._enforce(req, 'GetTemplate') con = req.context try: identity = self._get_identity(con, req.params['StackName']) templ = self.rpc_client.get_template(con, identity) except Exception as ex: return exception.map_remote_error(ex) if templ is None: msg = _('stack not not found') return exception.HeatInvalidParameterValueError(detail=msg) return api_utils.format_response('GetTemplate', {'TemplateBody': templ}) def estimate_template_cost(self, req): """ Implements the EstimateTemplateCost API action Get the estimated monthly cost of a template """ self._enforce(req, 'EstimateTemplateCost') return api_utils.format_response('EstimateTemplateCost', {'Url': 'http://en.wikipedia.org/wiki/Gratis' } ) def validate_template(self, req): """ Implements the ValidateTemplate API action. Validates the specified template. """ self._enforce(req, 'ValidateTemplate') con = req.context try: templ = self._get_template(req) except socket.gaierror: msg = _('Invalid Template URL') return exception.HeatInvalidParameterValueError(detail=msg) if templ is None: msg = _("TemplateBody or TemplateUrl were not given.") return exception.HeatMissingParameterError(detail=msg) try: template = template_format.parse(templ) except ValueError: msg = _("The Template must be a JSON or YAML document.") return exception.HeatInvalidParameterValueError(detail=msg) logger.info('validate_template') def format_validate_parameter(key, value): """ Reformat engine output into the AWS "ValidateTemplate" format """ return { 'ParameterKey': key, 'DefaultValue': value.get(engine_api.PARAM_DEFAULT, ''), 'Description': value.get(engine_api.PARAM_DESCRIPTION, ''), 'NoEcho': value.get(engine_api.PARAM_NO_ECHO, 'false') } try: res = self.rpc_client.validate_template(con, template) if 'Error' in res: return api_utils.format_response('ValidateTemplate', res['Error']) res['Parameters'] = [format_validate_parameter(k, v) for k, v in res['Parameters'].items()] return api_utils.format_response('ValidateTemplate', res) except Exception as ex: return exception.map_remote_error(ex) def delete(self, req): """ Implements the DeleteStack API action. Deletes the specified stack. """ self._enforce(req, 'DeleteStack') con = req.context try: identity = self._get_identity(con, req.params['StackName']) res = self.rpc_client.delete_stack(con, identity, cast=False) except Exception as ex: return exception.map_remote_error(ex) if res is None: return api_utils.format_response('DeleteStack', '') else: return api_utils.format_response('DeleteStack', res['Error']) def events_list(self, req): """ Implements the DescribeStackEvents API action. Returns events related to a specified stack (or all stacks). """ self._enforce(req, 'DescribeStackEvents') def format_stack_event(e): """ Reformat engine output into the AWS "StackEvent" format """ keymap = { engine_api.EVENT_ID: 'EventId', engine_api.EVENT_RES_NAME: 'LogicalResourceId', engine_api.EVENT_RES_PHYSICAL_ID: 'PhysicalResourceId', engine_api.EVENT_RES_PROPERTIES: 'ResourceProperties', engine_api.EVENT_RES_STATUS_DATA: 'ResourceStatusReason', engine_api.EVENT_RES_TYPE: 'ResourceType', engine_api.EVENT_STACK_ID: 'StackId', engine_api.EVENT_STACK_NAME: 'StackName', engine_api.EVENT_TIMESTAMP: 'Timestamp', } result = api_utils.reformat_dict_keys(keymap, e) action = e[engine_api.EVENT_RES_ACTION] status = e[engine_api.EVENT_RES_STATUS] result['ResourceStatus'] = '_'.join((action, status)) result['ResourceProperties'] = json.dumps(result[ 'ResourceProperties']) return self._id_format(result) con = req.context stack_name = req.params.get('StackName') try: identity = stack_name and self._get_identity(con, stack_name) events = self.rpc_client.list_events(con, identity) except Exception as ex: return exception.map_remote_error(ex) result = [format_stack_event(e) for e in events] return api_utils.format_response('DescribeStackEvents', {'StackEvents': result}) @staticmethod def _resource_status(res): action = res[engine_api.RES_ACTION] status = res[engine_api.RES_STATUS] return '_'.join((action, status)) def describe_stack_resource(self, req): """ Implements the DescribeStackResource API action. Return the details of the given resource belonging to the given stack. """ self._enforce(req, 'DescribeStackResource') def format_resource_detail(r): # Reformat engine output into the AWS "StackResourceDetail" format keymap = { engine_api.RES_DESCRIPTION: 'Description', engine_api.RES_UPDATED_TIME: 'LastUpdatedTimestamp', engine_api.RES_NAME: 'LogicalResourceId', engine_api.RES_METADATA: 'Metadata', engine_api.RES_PHYSICAL_ID: 'PhysicalResourceId', engine_api.RES_STATUS_DATA: 'ResourceStatusReason', engine_api.RES_TYPE: 'ResourceType', engine_api.RES_STACK_ID: 'StackId', engine_api.RES_STACK_NAME: 'StackName', } result = api_utils.reformat_dict_keys(keymap, r) result['ResourceStatus'] = self._resource_status(r) return self._id_format(result) con = req.context try: identity = self._get_identity(con, req.params['StackName']) resource_details = self.rpc_client.describe_stack_resource( con, stack_identity=identity, resource_name=req.params.get('LogicalResourceId')) except Exception as ex: return exception.map_remote_error(ex) result = format_resource_detail(resource_details) return api_utils.format_response('DescribeStackResource', {'StackResourceDetail': result}) def describe_stack_resources(self, req): """ Implements the DescribeStackResources API action Return details of resources specified by the parameters. `StackName`: returns all resources belonging to the stack. `PhysicalResourceId`: returns all resources belonging to the stack this resource is associated with. Only one of the parameters may be specified. Optional parameter: `LogicalResourceId`: filter the resources list by the logical resource id. """ self._enforce(req, 'DescribeStackResources') def format_stack_resource(r): """ Reformat engine output into the AWS "StackResource" format """ keymap = { engine_api.RES_DESCRIPTION: 'Description', engine_api.RES_NAME: 'LogicalResourceId', engine_api.RES_PHYSICAL_ID: 'PhysicalResourceId', engine_api.RES_STATUS_DATA: 'ResourceStatusReason', engine_api.RES_TYPE: 'ResourceType', engine_api.RES_STACK_ID: 'StackId', engine_api.RES_STACK_NAME: 'StackName', engine_api.RES_UPDATED_TIME: 'Timestamp', } result = api_utils.reformat_dict_keys(keymap, r) result['ResourceStatus'] = self._resource_status(r) return self._id_format(result) con = req.context stack_name = req.params.get('StackName') physical_resource_id = req.params.get('PhysicalResourceId') if stack_name and physical_resource_id: msg = 'Use `StackName` or `PhysicalResourceId` but not both' return exception.HeatInvalidParameterCombinationError(detail=msg) try: if stack_name is not None: identity = self._get_identity(con, stack_name) else: identity = self.rpc_client.find_physical_resource( con, physical_resource_id=physical_resource_id) resources = self.rpc_client.describe_stack_resources( con, stack_identity=identity, resource_name=req.params.get('LogicalResourceId')) except Exception as ex: return exception.map_remote_error(ex) result = [format_stack_resource(r) for r in resources] return api_utils.format_response('DescribeStackResources', {'StackResources': result}) def list_stack_resources(self, req): """ Implements the ListStackResources API action Return summary of the resources belonging to the specified stack. """ self._enforce(req, 'ListStackResources') def format_resource_summary(r): """ Reformat engine output into the AWS "StackResourceSummary" format """ keymap = { engine_api.RES_UPDATED_TIME: 'LastUpdatedTimestamp', engine_api.RES_NAME: 'LogicalResourceId', engine_api.RES_PHYSICAL_ID: 'PhysicalResourceId', engine_api.RES_STATUS_DATA: 'ResourceStatusReason', engine_api.RES_TYPE: 'ResourceType', } result = api_utils.reformat_dict_keys(keymap, r) result['ResourceStatus'] = self._resource_status(r) return result con = req.context try: identity = self._get_identity(con, req.params['StackName']) resources = self.rpc_client.list_stack_resources( con, stack_identity=identity) except Exception as ex: return exception.map_remote_error(ex) summaries = [format_resource_summary(r) for r in resources] return api_utils.format_response('ListStackResources', {'StackResourceSummaries': summaries}) def create_resource(options): """ Stacks resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() return wsgi.Resource(StackController(options), deserializer) heat-2014.1.5/heat/api/cfn/v1/signal.py0000664000567000056700000000374112540642614020453 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. from heat.api.aws import exception from heat.common import identifier from heat.common import wsgi from heat.rpc import client as rpc_client class SignalController(object): def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() def update_waitcondition(self, req, body, arn): con = req.context identity = identifier.ResourceIdentifier.from_arn(arn) try: md = self.rpc_client.metadata_update( con, stack_identity=dict(identity.stack()), resource_name=identity.resource_name, metadata=body) except Exception as ex: return exception.map_remote_error(ex) return {'resource': identity.resource_name, 'metadata': md} def signal(self, req, arn, body=None): con = req.context identity = identifier.ResourceIdentifier.from_arn(arn) try: self.rpc_client.resource_signal( con, stack_identity=dict(identity.stack()), resource_name=identity.resource_name, details=body) except Exception as ex: return exception.map_remote_error(ex) def create_resource(options): """ Signal resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() return wsgi.Resource(SignalController(options), deserializer) heat-2014.1.5/heat/api/cfn/v1/__init__.py0000664000567000056700000000572412540642614020740 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. import routes from webob import Request from heat.api.cfn.v1 import signal from heat.api.cfn.v1 import stacks from heat.common import wsgi from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class API(wsgi.Router): """ WSGI router for Heat CloudFormation v1 API requests. """ _actions = { 'list': 'ListStacks', 'create': 'CreateStack', 'describe': 'DescribeStacks', 'delete': 'DeleteStack', 'update': 'UpdateStack', 'events_list': 'DescribeStackEvents', 'validate_template': 'ValidateTemplate', 'get_template': 'GetTemplate', 'estimate_template_cost': 'EstimateTemplateCost', 'describe_stack_resource': 'DescribeStackResource', 'describe_stack_resources': 'DescribeStackResources', 'list_stack_resources': 'ListStackResources', } def __init__(self, conf, **local_conf): self.conf = conf mapper = routes.Mapper() stacks_resource = stacks.create_resource(conf) mapper.resource("stack", "stacks", controller=stacks_resource, collection={'detail': 'GET'}) def conditions(action): api_action = self._actions[action] def action_match(environ, result): req = Request(environ) env_action = req.params.get("Action") return env_action == api_action return {'function': action_match} for action in self._actions: mapper.connect("/", controller=stacks_resource, action=action, conditions=conditions(action)) mapper.connect("/", controller=stacks_resource, action="index") # Add controller which handles signals on resources like: # waitconditions and alarms. # This is not part of the main CFN API spec, hence handle it # separately via a different path signal_controller = signal.create_resource(conf) mapper.connect('/waitcondition/{arn:.*}', controller=signal_controller, action='update_waitcondition', conditions=dict(method=['PUT'])) mapper.connect('/signal/{arn:.*}', controller=signal_controller, action='signal', conditions=dict(method=['POST'])) super(API, self).__init__(mapper) heat-2014.1.5/heat/api/__init__.py0000664000567000056700000000000012540642611017617 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/aws/0000775000567000056700000000000012540643116016313 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/aws/ec2token.py0000664000567000056700000002231112540642614020400 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. import hashlib from oslo.config import cfg import requests import webob from heat.api.aws import exception from heat.api.aws.exception import HeatAPIException from heat.common import wsgi from heat.openstack.common import gettextutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import importutils from heat.openstack.common import jsonutils as json from heat.openstack.common import log as logging gettextutils.install('heat') logger = logging.getLogger(__name__) opts = [ cfg.StrOpt('auth_uri', default=None, help=_("Authentication Endpoint URI.")), cfg.BoolOpt('multi_cloud', default=False, help=_('Allow orchestration of multiple clouds.')), cfg.ListOpt('allowed_auth_uris', default=[], help=_('Allowed keystone endpoints for auth_uri when ' 'multi_cloud is enabled. At least one endpoint needs ' 'to be specified.')) ] cfg.CONF.register_opts(opts, group='ec2authtoken') class EC2Token(wsgi.Middleware): """Authenticate an EC2 request with keystone and convert to token.""" def __init__(self, app, conf): self.conf = conf self.application = app def _conf_get(self, name): # try config from paste-deploy first if name in self.conf: return self.conf[name] else: return cfg.CONF.ec2authtoken[name] def _conf_get_auth_uri(self): auth_uri = self._conf_get('auth_uri') if auth_uri: return auth_uri else: # Import auth_token to have keystone_authtoken settings setup. # We can use the auth_uri from the keystone_authtoken section importutils.import_module('keystoneclient.middleware.auth_token') return cfg.CONF.keystone_authtoken['auth_uri'] @staticmethod def _conf_get_keystone_ec2_uri(auth_uri): if auth_uri.endswith('/'): return '%sec2tokens' % auth_uri return '%s/ec2tokens' % auth_uri def _get_signature(self, req): """ Extract the signature from the request, this can be a get/post variable or for v4 also in a header called 'Authorization' - params['Signature'] == version 0,1,2,3 - params['X-Amz-Signature'] == version 4 - header 'Authorization' == version 4 """ sig = req.params.get('Signature') or req.params.get('X-Amz-Signature') if sig is None and 'Authorization' in req.headers: auth_str = req.headers['Authorization'] sig = auth_str.partition("Signature=")[2].split(',')[0] return sig def _get_access(self, req): """ Extract the access key identifier, for v 0/1/2/3 this is passed as the AccessKeyId parameter, for version4 it is either and X-Amz-Credential parameter or a Credential= field in the 'Authorization' header string """ access = req.params.get('AWSAccessKeyId') if access is None: cred_param = req.params.get('X-Amz-Credential') if cred_param: access = cred_param.split("/")[0] if access is None and 'Authorization' in req.headers: auth_str = req.headers['Authorization'] cred_str = auth_str.partition("Credential=")[2].split(',')[0] access = cred_str.split("/")[0] return access @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): if not self._conf_get('multi_cloud'): return self._authorize(req, self._conf_get_auth_uri()) else: # attempt to authorize for each configured allowed_auth_uris # until one is successful. # This is safe for the following reasons: # 1. AWSAccessKeyId is a randomly generated sequence # 2. No secret is transferred to validate a request last_failure = None for auth_uri in self._conf_get('allowed_auth_uris'): try: logger.debug(_("Attempt authorize on %s") % auth_uri) return self._authorize(req, auth_uri) except HeatAPIException as e: logger.debug(_("Authorize failed: %s") % e.__class__) last_failure = e raise last_failure or exception.HeatAccessDeniedError() def _authorize(self, req, auth_uri): # Read request signature and access id. # If we find X-Auth-User in the headers we ignore a key error # here so that we can use both authentication methods. # Returning here just means the user didn't supply AWS # authentication and we'll let the app try native keystone next. logger.info(_("Checking AWS credentials..")) signature = self._get_signature(req) if not signature: if 'X-Auth-User' in req.headers: return self.application else: logger.info(_("No AWS Signature found.")) raise exception.HeatIncompleteSignatureError() access = self._get_access(req) if not access: if 'X-Auth-User' in req.headers: return self.application else: logger.info(_("No AWSAccessKeyId/Authorization Credential")) raise exception.HeatMissingAuthenticationTokenError() logger.info(_("AWS credentials found, checking against keystone.")) if not auth_uri: logger.error(_("Ec2Token authorization failed, no auth_uri " "specified in config file")) raise exception.HeatInternalFailureError(_('Service ' 'misconfigured')) # Make a copy of args for authentication and signature verification. auth_params = dict(req.params) # 'Signature' param Not part of authentication args auth_params.pop('Signature', None) # Authenticate the request. # AWS v4 authentication requires a hash of the body body_hash = hashlib.sha256(req.body).hexdigest() creds = {'ec2Credentials': {'access': access, 'signature': signature, 'host': req.host, 'verb': req.method, 'path': req.path, 'params': auth_params, 'headers': req.headers, 'body_hash': body_hash }} creds_json = json.dumps(creds) headers = {'Content-Type': 'application/json'} keystone_ec2_uri = self._conf_get_keystone_ec2_uri(auth_uri) logger.info(_('Authenticating with %s') % keystone_ec2_uri) response = requests.post(keystone_ec2_uri, data=creds_json, headers=headers) result = response.json() try: token_id = result['access']['token']['id'] tenant = result['access']['token']['tenant']['name'] tenant_id = result['access']['token']['tenant']['id'] logger.info(_("AWS authentication successful.")) except (AttributeError, KeyError): logger.info(_("AWS authentication failure.")) # Try to extract the reason for failure so we can return the # appropriate AWS error via raising an exception try: reason = result['error']['message'] except KeyError: reason = None if reason == "EC2 access key not found.": raise exception.HeatInvalidClientTokenIdError() elif reason == "EC2 signature not supplied.": raise exception.HeatSignatureError() else: raise exception.HeatAccessDeniedError() # Authenticated! ec2_creds = {'ec2Credentials': {'access': access, 'signature': signature}} req.headers['X-Auth-EC2-Creds'] = json.dumps(ec2_creds) req.headers['X-Auth-Token'] = token_id req.headers['X-Tenant-Name'] = tenant req.headers['X-Tenant-Id'] = tenant_id req.headers['X-Auth-URL'] = auth_uri metadata = result['access'].get('metadata', {}) roles = metadata.get('roles', []) req.headers['X-Roles'] = ','.join(roles) return self.application def EC2Token_filter_factory(global_conf, **local_conf): """ Factory method for paste.deploy """ conf = global_conf.copy() conf.update(local_conf) def filter(app): return EC2Token(app, conf) return filter heat-2014.1.5/heat/api/aws/exception.py0000664000567000056700000002323612540642614020673 0ustar jenkinsjenkins00000000000000 # Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # # 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 API exception subclasses - maps API response errors to AWS Errors""" import webob.exc from heat.common import wsgi from heat.openstack.common.gettextutils import _ from heat.openstack.common.rpc import common as rpc_common class HeatAPIException(webob.exc.HTTPError): ''' Subclass webob HTTPError so we can correctly serialize the wsgi response into the http response body, using the format specified by the request. Note this should not be used directly, instead use of of the subclasses defined below which map to AWS API errors ''' code = 400 title = "HeatAPIException" explanation = _("Generic HeatAPIException, please use specific " "subclasses!") err_type = "Sender" def __init__(self, detail=None): ''' Overload HTTPError constructor, so we can create a default serialized body. This is required because not all error responses are processed by the wsgi controller (ie auth errors, which are further up the paste pipeline. We serialize in XML by default (as AWS does) ''' webob.exc.HTTPError.__init__(self, detail=detail) serializer = wsgi.XMLResponseSerializer() serializer.default(self, self.get_unserialized_body()) def get_unserialized_body(self): ''' Return a dict suitable for serialization in the wsgi controller This wraps the exception details in a format which maps to the expected format for the AWS API ''' # Note the aws response format specifies a "Code" element which is not # the html response code, but the AWS API error code, e.g self.title if self.detail: message = ":".join([self.explanation, self.detail]) else: message = self.explanation return {'ErrorResponse': {'Error': {'Type': self.err_type, 'Code': self.title, 'Message': message}}} # Common Error Subclasses: class HeatIncompleteSignatureError(HeatAPIException): ''' The request signature does not conform to AWS standards ''' code = 400 title = "IncompleteSignature" explanation = _("The request signature does not conform to AWS standards") class HeatInternalFailureError(HeatAPIException): ''' The request processing has failed due to some unknown error ''' code = 500 title = "InternalFailure" explanation = _("The request processing has failed due to an " "internal error") err_type = "Server" class HeatInvalidActionError(HeatAPIException): ''' The action or operation requested is invalid ''' code = 400 title = "InvalidAction" explanation = _("The action or operation requested is invalid") class HeatInvalidClientTokenIdError(HeatAPIException): ''' The X.509 certificate or AWS Access Key ID provided does not exist ''' code = 403 title = "InvalidClientTokenId" explanation = _("The certificate or AWS Key ID provided does not exist") class HeatInvalidParameterCombinationError(HeatAPIException): ''' Parameters that must not be used together were used together ''' code = 400 title = "InvalidParameterCombination" explanation = _("Incompatible parameters were used together") class HeatInvalidParameterValueError(HeatAPIException): ''' A bad or out-of-range value was supplied for the input parameter ''' code = 400 title = "InvalidParameterValue" explanation = _("A bad or out-of-range value was supplied") class HeatInvalidQueryParameterError(HeatAPIException): ''' AWS query string is malformed, does not adhere to AWS standards ''' code = 400 title = "InvalidQueryParameter" explanation = _("AWS query string is malformed, does not adhere to " "AWS spec") class HeatMalformedQueryStringError(HeatAPIException): ''' The query string is malformed ''' code = 404 title = "MalformedQueryString" explanation = _("The query string is malformed") class HeatMissingActionError(HeatAPIException): ''' The request is missing an action or operation parameter ''' code = 400 title = "MissingAction" explanation = _("The request is missing an action or operation parameter") class HeatMissingAuthenticationTokenError(HeatAPIException): ''' Request must contain either a valid (registered) AWS Access Key ID or X.509 certificate ''' code = 403 title = "MissingAuthenticationToken" explanation = _("Does not contain a valid AWS Access Key or certificate") class HeatMissingParameterError(HeatAPIException): ''' An input parameter that is mandatory for processing the request is missing ''' code = 400 title = "MissingParameter" explanation = _("A mandatory input parameter is missing") class HeatOptInRequiredError(HeatAPIException): ''' The AWS Access Key ID needs a subscription for the service ''' code = 403 title = "OptInRequired" explanation = _("The AWS Access Key ID needs a subscription for the " "service") class HeatRequestExpiredError(HeatAPIException): ''' Request is past expires date or the request date (either with 15 minute padding), or the request date occurs more than 15 minutes in the future ''' code = 400 title = "RequestExpired" explanation = _("Request expired or more than 15mins in the future") class HeatServiceUnavailableError(HeatAPIException): ''' The request has failed due to a temporary failure of the server ''' code = 503 title = "ServiceUnavailable" explanation = _("Service temporarily unavailable") err_type = "Server" class HeatThrottlingError(HeatAPIException): ''' Request was denied due to request throttling ''' code = 400 title = "Throttling" explanation = _("Request was denied due to request throttling") class AlreadyExistsError(HeatAPIException): ''' Resource with the name requested already exists ''' code = 400 title = 'AlreadyExists' explanation = _("Resource with the name requested already exists") # Not documented in the AWS docs, authentication failure errors class HeatAccessDeniedError(HeatAPIException): ''' This is the response given when authentication fails due to user IAM group memberships meaning we deny access ''' code = 403 title = "AccessDenied" explanation = _("User is not authorized to perform action") class HeatSignatureError(HeatAPIException): ''' This is the response given when authentication fails due to a bad signature ''' code = 403 title = "SignatureDoesNotMatch" explanation = _("The request signature we calculated does not match the " "signature you provided") # Heat-specific errors class HeatAPINotImplementedError(HeatAPIException): ''' This is the response given when an API action is not yet implemented ''' code = 500 title = "APINotImplemented" explanation = _("The requested action is not yet implemented") err_type = "Server" class HeatActionInProgressError(HeatAPIException): ''' Cannot perform action on stack in its current state ''' code = 400 title = 'InvalidAction' explanation = ("Cannot perform action on stack while other actions are " + "in progress") def map_remote_error(ex): """ Map rpc_common.RemoteError exceptions returned by the engine to HeatAPIException subclasses which can be used to return properly formatted AWS error responses """ inval_param_errors = ( 'AttributeError', 'ValueError', 'InvalidTenant', 'StackNotFound', 'ResourceNotFound', 'ResourceNotAvailable', 'ResourceTypeNotFound', 'PhysicalResourceNotFound', 'WatchRuleNotFound', 'StackValidationFailed', 'InvalidTemplateReference', 'InvalidTemplateVersion', 'InvalidTemplateSection', 'UnknownUserParameter', 'UserParameterMissing', 'InvalidTemplateParameter', ) denied_errors = ('Forbidden', 'NotAuthorized') already_exists_errors = ('StackExists') invalid_action_errors = ('ActionInProgress',) ex_type = ex.__class__.__name__ if ex_type.endswith(rpc_common._REMOTE_POSTFIX): ex_type = ex_type[:-len(rpc_common._REMOTE_POSTFIX)] if ex_type in inval_param_errors: return HeatInvalidParameterValueError(detail=str(ex)) elif ex_type in denied_errors: return HeatAccessDeniedError(detail=str(ex)) elif ex_type in already_exists_errors: return AlreadyExistsError(detail=str(ex)) elif ex_type in invalid_action_errors: return HeatActionInProgressError(detail=str(ex)) else: # Map everything else to internal server error for now return HeatInternalFailureError(detail=str(ex)) heat-2014.1.5/heat/api/aws/__init__.py0000664000567000056700000000000012540642611020411 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/aws/utils.py0000664000567000056700000000674212540642614020040 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. ''' Helper utilities related to the AWS API implementations ''' import itertools import re from heat.api.aws import exception from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging LOG = logging.getLogger(__name__) def format_response(action, response): """ Format response from engine into API format """ return {'%sResponse' % action: {'%sResult' % action: response}} def extract_param_pairs(params, prefix='', keyname='', valuename=''): """ Extract a dictionary of user input parameters, from AWS style parameter-pair encoded list In the AWS API list items appear as two key-value pairs (passed as query parameters) with keys of the form below: Prefix.member.1.keyname=somekey Prefix.member.1.keyvalue=somevalue Prefix.member.2.keyname=anotherkey Prefix.member.2.keyvalue=somevalue We reformat this into a dict here to match the heat engine API expected format """ plist = extract_param_list(params, prefix) kvs = [(p[keyname], p[valuename]) for p in plist if keyname in p and valuename in p] return dict(kvs) def extract_param_list(params, prefix=''): """ Extract a list-of-dicts based on parameters containing AWS style list MetricData.member.1.MetricName=buffers MetricData.member.1.Unit=Bytes MetricData.member.1.Value=231434333 MetricData.member.2.MetricName=buffers2 MetricData.member.2.Unit=Bytes MetricData.member.2.Value=12345 This can be extracted by passing prefix=MetricData, resulting in a list containing two dicts """ key_re = re.compile(r"%s\.member\.([0-9]+)\.(.*)" % (prefix)) def get_param_data(params): for param_name, value in params.items(): match = key_re.match(param_name) if match: try: index = int(match.group(1)) except ValueError: pass else: key = match.group(2) yield (index, (key, value)) # Sort and group by index key_func = lambda d: d[0] data = sorted(get_param_data(params), key=key_func) members = itertools.groupby(data, key_func) return [dict(kv for di, kv in m) for mi, m in members] def get_param_value(params, key): """ Helper function, looks up an expected parameter in a parsed params dict and returns the result. If params does not contain the requested key we raise an exception of the appropriate type """ try: return params[key] except KeyError: LOG.error(_("Request does not contain %s parameter!") % key) raise exception.HeatMissingParameterError(key) def reformat_dict_keys(keymap={}, inputdict={}): ''' Utility function for mapping one dict format to another ''' return dict([(outk, inputdict[ink]) for ink, outk in keymap.items() if ink in inputdict]) heat-2014.1.5/heat/api/cloudwatch/0000775000567000056700000000000012540643116017656 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/api/cloudwatch/versions.py0000664000567000056700000000313012540642614022077 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. """ Controller that returns information on the heat API versions """ import httplib import json import webob.dec class Controller(object): """ A controller that produces information on the heat API versions. """ def __init__(self, conf): self.conf = conf @webob.dec.wsgify def __call__(self, req): """Respond to a request for all OpenStack API versions.""" version_objs = [ { "id": "v1.0", "status": "CURRENT", "links": [ { "rel": "self", "href": self.get_href(req) }] }] body = json.dumps(dict(versions=version_objs)) response = webob.Response(request=req, status=httplib.MULTIPLE_CHOICES, content_type='application/json') response.body = body return response def get_href(self, req): return "%s/v1/" % req.host_url heat-2014.1.5/heat/api/cloudwatch/__init__.py0000664000567000056700000000501112540642614021766 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. import routes from webob import Request from heat.api.cloudwatch import versions from heat.api.cloudwatch import watch from heat.api.middleware.version_negotiation import VersionNegotiationFilter from heat.common import wsgi from heat.openstack.common import gettextutils from heat.openstack.common import log as logging logger = logging.getLogger(__name__) gettextutils.install('heat') class API(wsgi.Router): """ WSGI router for Heat CloudWatch API """ _actions = { 'delete_alarms': 'DeleteAlarms', 'describe_alarm_history': 'DescribeAlarmHistory', 'describe_alarms': 'DescribeAlarms', 'describe_alarms_for_metric': 'DescribeAlarmsForMetric', 'disable_alarm_actions': 'DisableAlarmActions', 'enable_alarm_actions': 'EnableAlarmActions', 'get_metric_statistics': 'GetMetricStatistics', 'list_metrics': 'ListMetrics', 'put_metric_alarm': 'PutMetricAlarm', 'put_metric_data': 'PutMetricData', 'set_alarm_state': 'SetAlarmState', } def __init__(self, conf, **local_conf): self.conf = conf mapper = routes.Mapper() controller_resource = watch.create_resource(conf) def conditions(action): api_action = self._actions[action] def action_match(environ, result): req = Request(environ) env_action = req.params.get("Action") return env_action == api_action return {'function': action_match} for action in self._actions: mapper.connect("/", controller=controller_resource, action=action, conditions=conditions(action)) mapper.connect("/", controller=controller_resource, action="index") super(API, self).__init__(mapper) def version_negotiation_filter(app, conf, **local_conf): return VersionNegotiationFilter(versions.Controller, app, conf, **local_conf) heat-2014.1.5/heat/api/cloudwatch/watch.py0000664000567000056700000003147312540642614021350 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. """ endpoint for heat AWS-compatible CloudWatch API """ from heat.api.aws import exception from heat.api.aws import utils as api_utils from heat.common import exception as heat_exception from heat.common import policy from heat.common import wsgi from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.rpc import common as rpc_common from heat.rpc import api as engine_api from heat.rpc import client as rpc_client logger = logging.getLogger(__name__) class WatchController(object): """ WSGI controller for CloudWatch resource in heat API Implements the API actions """ def __init__(self, options): self.options = options self.rpc_client = rpc_client.EngineClient() self.policy = policy.Enforcer(scope='cloudwatch') def _enforce(self, req, action): """Authorize an action against the policy.json.""" try: self.policy.enforce(req.context, action) except heat_exception.Forbidden: msg = _("Action %s not allowed for user") % action raise exception.HeatAccessDeniedError(msg) except Exception: # We expect policy.enforce to either pass or raise Forbidden # however, if anything else happens, we want to raise # HeatInternalFailureError, failure to do this results in # the user getting a big stacktrace spew as an API response msg = _("Error authorizing action %s") % action raise exception.HeatInternalFailureError(msg) @staticmethod def _reformat_dimensions(dims): ''' Reformat dimensions list into AWS API format Parameter dims is a list of dicts ''' newdims = [] for count, d in enumerate(dims, 1): for key in d.keys(): newdims.append({'Name': key, 'Value': d[key]}) return newdims def delete_alarms(self, req): """ Implements DeleteAlarms API action """ self._enforce(req, 'DeleteAlarms') return exception.HeatAPINotImplementedError() def describe_alarm_history(self, req): """ Implements DescribeAlarmHistory API action """ self._enforce(req, 'DescribeAlarmHistory') return exception.HeatAPINotImplementedError() def describe_alarms(self, req): """ Implements DescribeAlarms API action """ self._enforce(req, 'DescribeAlarms') def format_metric_alarm(a): """ Reformat engine output into the AWS "MetricAlarm" format """ keymap = { engine_api.WATCH_ACTIONS_ENABLED: 'ActionsEnabled', engine_api.WATCH_ALARM_ACTIONS: 'AlarmActions', engine_api.WATCH_TOPIC: 'AlarmArn', engine_api.WATCH_UPDATED_TIME: 'AlarmConfigurationUpdatedTimestamp', engine_api.WATCH_DESCRIPTION: 'AlarmDescription', engine_api.WATCH_NAME: 'AlarmName', engine_api.WATCH_COMPARISON: 'ComparisonOperator', engine_api.WATCH_DIMENSIONS: 'Dimensions', engine_api.WATCH_PERIODS: 'EvaluationPeriods', engine_api.WATCH_INSUFFICIENT_ACTIONS: 'InsufficientDataActions', engine_api.WATCH_METRIC_NAME: 'MetricName', engine_api.WATCH_NAMESPACE: 'Namespace', engine_api.WATCH_OK_ACTIONS: 'OKActions', engine_api.WATCH_PERIOD: 'Period', engine_api.WATCH_STATE_REASON: 'StateReason', engine_api.WATCH_STATE_REASON_DATA: 'StateReasonData', engine_api.WATCH_STATE_UPDATED_TIME: 'StateUpdatedTimestamp', engine_api.WATCH_STATE_VALUE: 'StateValue', engine_api.WATCH_STATISTIC: 'Statistic', engine_api.WATCH_THRESHOLD: 'Threshold', engine_api.WATCH_UNIT: 'Unit'} # AWS doesn't return StackId in the main MetricAlarm # structure, so we add StackId as a dimension to all responses a[engine_api.WATCH_DIMENSIONS].append({'StackId': a[engine_api.WATCH_STACK_ID] }) # Reformat dimensions list into AWS API format a[engine_api.WATCH_DIMENSIONS] = self._reformat_dimensions( a[engine_api.WATCH_DIMENSIONS]) return api_utils.reformat_dict_keys(keymap, a) con = req.context parms = dict(req.params) try: name = parms['AlarmName'] except KeyError: name = None try: watch_list = self.rpc_client.show_watch(con, watch_name=name) except rpc_common.RemoteError as ex: return exception.map_remote_error(ex) res = {'MetricAlarms': [format_metric_alarm(a) for a in watch_list]} result = api_utils.format_response("DescribeAlarms", res) return result def describe_alarms_for_metric(self, req): """ Implements DescribeAlarmsForMetric API action """ self._enforce(req, 'DescribeAlarmsForMetric') return exception.HeatAPINotImplementedError() def disable_alarm_actions(self, req): """ Implements DisableAlarmActions API action """ self._enforce(req, 'DisableAlarmActions') return exception.HeatAPINotImplementedError() def enable_alarm_actions(self, req): """ Implements EnableAlarmActions API action """ self._enforce(req, 'EnableAlarmActions') return exception.HeatAPINotImplementedError() def get_metric_statistics(self, req): """ Implements GetMetricStatistics API action """ self._enforce(req, 'GetMetricStatistics') return exception.HeatAPINotImplementedError() def list_metrics(self, req): """ Implements ListMetrics API action Lists metric datapoints associated with a particular alarm, or all alarms if none specified """ self._enforce(req, 'ListMetrics') def format_metric_data(d, fil={}): """ Reformat engine output into the AWS "Metric" format Takes an optional filter dict, which is traversed so a metric dict is only returned if all keys match the filter dict """ dimensions = [ {'AlarmName': d[engine_api.WATCH_DATA_ALARM]}, {'Timestamp': d[engine_api.WATCH_DATA_TIME]} ] for key in d[engine_api.WATCH_DATA]: dimensions.append({key: d[engine_api.WATCH_DATA][key]}) newdims = self._reformat_dimensions(dimensions) result = { 'MetricName': d[engine_api.WATCH_DATA_METRIC], 'Dimensions': newdims, 'Namespace': d[engine_api.WATCH_DATA_NAMESPACE], } for f in fil: try: value = result[f] if value != fil[f]: # Filter criteria not met, return None return except KeyError: logger.warning(_("Invalid filter key %s, ignoring") % f) return result con = req.context parms = dict(req.params) # FIXME : Don't yet handle filtering by Dimensions filter_result = dict((k, v) for (k, v) in parms.iteritems() if k in ("MetricName", "Namespace")) logger.debug(_("filter parameters : %s") % filter_result) try: # Engine does not currently support query by namespace/metric # so we pass None/None and do any filtering locally null_kwargs = {'metric_namespace': None, 'metric_name': None} watch_data = self.rpc_client.show_watch_metric(con, **null_kwargs) except rpc_common.RemoteError as ex: return exception.map_remote_error(ex) res = {'Metrics': []} for d in watch_data: metric = format_metric_data(d, filter_result) if metric: res['Metrics'].append(metric) result = api_utils.format_response("ListMetrics", res) return result def put_metric_alarm(self, req): """ Implements PutMetricAlarm API action """ self._enforce(req, 'PutMetricAlarm') return exception.HeatAPINotImplementedError() def put_metric_data(self, req): """ Implements PutMetricData API action """ self._enforce(req, 'PutMetricData') con = req.context parms = dict(req.params) namespace = api_utils.get_param_value(parms, 'Namespace') # Extract data from the request so we can pass it to the engine # We have to do this in two passes, because the AWS # query format nests the dimensions within the MetricData # query-parameter-list (see AWS PutMetricData docs) # extract_param_list gives a list-of-dict, which we then # need to process (each dict) for dimensions metric_data = api_utils.extract_param_list(parms, prefix='MetricData') if not len(metric_data): logger.error(_("Request does not contain required MetricData")) return exception.HeatMissingParameterError("MetricData list") watch_name = None dimensions = [] for p in metric_data: dimension = api_utils.extract_param_pairs(p, prefix='Dimensions', keyname='Name', valuename='Value') if 'AlarmName' in dimension: watch_name = dimension['AlarmName'] else: dimensions.append(dimension) # Extract the required data from the metric_data # and format dict to pass to engine data = {'Namespace': namespace, api_utils.get_param_value(metric_data[0], 'MetricName'): { 'Unit': api_utils.get_param_value(metric_data[0], 'Unit'), 'Value': api_utils.get_param_value(metric_data[0], 'Value'), 'Dimensions': dimensions}} try: self.rpc_client.create_watch_data(con, watch_name, data) except rpc_common.RemoteError as ex: return exception.map_remote_error(ex) result = {'ResponseMetadata': None} return api_utils.format_response("PutMetricData", result) def set_alarm_state(self, req): """ Implements SetAlarmState API action """ self._enforce(req, 'SetAlarmState') # Map from AWS state names to those used in the engine state_map = {'OK': engine_api.WATCH_STATE_OK, 'ALARM': engine_api.WATCH_STATE_ALARM, 'INSUFFICIENT_DATA': engine_api.WATCH_STATE_NODATA} con = req.context parms = dict(req.params) # Get mandatory parameters name = api_utils.get_param_value(parms, 'AlarmName') state = api_utils.get_param_value(parms, 'StateValue') if state not in state_map: msg = _('Invalid state %(state)s, ' 'expecting one of %(expect)s') % { 'state': state, 'expect': state_map.keys()} logger.error(msg) return exception.HeatInvalidParameterValueError(msg) logger.debug(_("setting %(name)s to %(state)s") % { 'name': name, 'state': state_map[state]}) try: self.rpc_client.set_watch_state(con, watch_name=name, state=state_map[state]) except rpc_common.RemoteError as ex: return exception.map_remote_error(ex) return api_utils.format_response("SetAlarmState", "") def create_resource(options): """ Watch resource factory method. """ deserializer = wsgi.JSONRequestDeserializer() return wsgi.Resource(WatchController(options), deserializer) heat-2014.1.5/heat/engine/0000775000567000056700000000000012540643116016215 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/notification/0000775000567000056700000000000012540643116020703 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/notification/stack.py0000664000567000056700000000276012540642614022371 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. from heat.openstack.common.notifier import api as notifier_api from heat.engine import api as engine_api from heat.engine import notification def send(stack): """Send usage notifications to the configured notification driver.""" # The current notifications have a start/end: # see: https://wiki.openstack.org/wiki/SystemUsageData # so to be consistent we translate our status into a known start/end/error # suffix. level = notification.get_default_level() if stack.status == stack.IN_PROGRESS: suffix = 'start' elif stack.status == stack.COMPLETE: suffix = 'end' else: suffix = 'error' level = notifier_api.ERROR event_type = '%s.%s.%s' % ('stack', stack.action.lower(), suffix) notification.notify(stack.context, event_type, level, engine_api.format_notification_body(stack)) heat-2014.1.5/heat/engine/notification/autoscaling.py0000664000567000056700000000271712540642614023577 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. from heat.openstack.common.notifier import api as notifier_api from heat.engine import api as engine_api from heat.engine import notification def send(stack, adjustment=None, adjustment_type=None, capacity=None, groupname=None, message='error', suffix=None): """Send autoscaling notifications to the configured notification driver.""" # see: https://wiki.openstack.org/wiki/SystemUsageData event_type = '%s.%s' % ('autoscaling', suffix) body = engine_api.format_notification_body(stack) body['adjustment_type'] = adjustment_type body['adjustment'] = adjustment body['capacity'] = capacity body['groupname'] = groupname body['message'] = message level = notification.get_default_level() if suffix == 'error': level = notifier_api.ERROR notification.notify(stack.context, event_type, level, body) heat-2014.1.5/heat/engine/notification/__init__.py0000664000567000056700000000264012540642614023020 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. from oslo.config import cfg from heat.openstack.common import log from heat.openstack.common.notifier import api as notifier_api LOG = log.getLogger(__name__) SERVICE = 'orchestration' CONF = cfg.CONF CONF.import_opt('default_notification_level', 'heat.openstack.common.notifier.api') CONF.import_opt('default_publisher_id', 'heat.openstack.common.notifier.api') def _get_default_publisher(): publisher_id = CONF.default_publisher_id if publisher_id is None: publisher_id = notifier_api.publisher_id(SERVICE) return publisher_id def get_default_level(): return CONF.default_notification_level.upper() def notify(context, event_type, level, body): notifier_api.notify(context, _get_default_publisher(), "%s.%s" % (SERVICE, event_type), level, body) heat-2014.1.5/heat/engine/parser.py0000664000567000056700000007256412540642614020103 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. import collections import copy from datetime import datetime import re import six from oslo.config import cfg from heat.engine import environment from heat.common import exception from heat.engine import dependencies from heat.common import identifier from heat.engine import function from heat.engine import resource from heat.engine import resources from heat.engine import scheduler from heat.engine import update from heat.engine.notification import stack as notification from heat.engine.parameter_groups import ParameterGroups from heat.engine.template import Template from heat.engine.clients import Clients from heat.db import api as db_api from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ from heat.openstack.common import strutils from heat.common.exception import StackValidationFailed logger = logging.getLogger(__name__) class Stack(collections.Mapping): ACTIONS = (CREATE, DELETE, UPDATE, ROLLBACK, SUSPEND, RESUME, ADOPT ) = ('CREATE', 'DELETE', 'UPDATE', 'ROLLBACK', 'SUSPEND', 'RESUME', 'ADOPT') STATUSES = (IN_PROGRESS, FAILED, COMPLETE ) = ('IN_PROGRESS', 'FAILED', 'COMPLETE') _zones = None def __init__(self, context, stack_name, tmpl, env=None, stack_id=None, action=None, status=None, status_reason='', timeout_mins=None, resolve_data=True, disable_rollback=True, parent_resource=None, owner_id=None, adopt_stack_data=None, stack_user_project_id=None, created_time=None, updated_time=None, user_creds_id=None, tenant_id=None, validate_parameters=True): ''' Initialise from a context, name, Template object and (optionally) Environment object. The database ID may also be initialised, if the stack is already in the database. ''' if owner_id is None: if re.match("[a-zA-Z][a-zA-Z0-9_.-]*$", stack_name) is None: raise ValueError(_('Invalid stack name %s' ' must contain only alphanumeric or ' '\"_-.\" characters, must start with alpha' ) % stack_name) self.id = stack_id self.owner_id = owner_id self.context = context self.clients = Clients(context) self.t = tmpl self.name = stack_name self.action = action self.status = status self.status_reason = status_reason self.timeout_mins = timeout_mins self.disable_rollback = disable_rollback self.parent_resource = parent_resource self._resources = None self._dependencies = None self._access_allowed_handlers = {} self.adopt_stack_data = adopt_stack_data self.stack_user_project_id = stack_user_project_id self.created_time = created_time self.updated_time = updated_time self.user_creds_id = user_creds_id # This will use the provided tenant ID when loading the stack # from the DB or get it from the context for new stacks. self.tenant_id = tenant_id or self.context.tenant_id resources.initialise() self.env = env or environment.Environment({}) self.parameters = self.t.parameters(self.identifier(), user_params=self.env.params) self.parameters.validate(validate_value=validate_parameters, context=context) self._set_param_stackid() if resolve_data: self.outputs = self.resolve_static_data(self.t[self.t.OUTPUTS]) else: self.outputs = {} @property def resources(self): if self._resources is None: template_resources = self.t[self.t.RESOURCES] self._resources = dict((name, resource.Resource(name, data, self)) for (name, data) in template_resources.items()) return self._resources @property def dependencies(self): if self._dependencies is None: self._dependencies = self._get_dependencies( self.resources.itervalues()) return self._dependencies def reset_dependencies(self): self._dependencies = None @property def root_stack(self): ''' Return the root stack if this is nested (otherwise return self). ''' if (self.parent_resource and self.parent_resource.stack): return self.parent_resource.stack.root_stack return self def total_resources(self): ''' Return the total number of resources in a stack, including nested stacks below. ''' def total_nested(res): get_nested = getattr(res, 'nested', None) if callable(get_nested): nested_stack = get_nested() if nested_stack is not None: return nested_stack.total_resources() return 0 return len(self) + sum(total_nested(res) for res in self.itervalues()) def _set_param_stackid(self): ''' Update self.parameters with the current ARN which is then provided via the Parameters class as the StackId pseudo parameter ''' if not self.parameters.set_stack_id(self.identifier()): logger.warning(_("Unable to set parameters StackId identifier")) @staticmethod def _get_dependencies(resources): '''Return the dependency graph for a list of resources.''' deps = dependencies.Dependencies() for resource in resources: resource.add_dependencies(deps) return deps @classmethod def load(cls, context, stack_id=None, stack=None, resolve_data=True, parent_resource=None, show_deleted=True): '''Retrieve a Stack from the database.''' if stack is None: stack = db_api.stack_get(context, stack_id, show_deleted=show_deleted) if stack is None: message = _('No stack exists with id "%s"') % str(stack_id) raise exception.NotFound(message) template = Template.load(context, stack.raw_template_id) env = environment.Environment(stack.parameters) stack = cls(context, stack.name, template, env, stack.id, stack.action, stack.status, stack.status_reason, stack.timeout, resolve_data, stack.disable_rollback, parent_resource, owner_id=stack.owner_id, stack_user_project_id=stack.stack_user_project_id, created_time=stack.created_at, updated_time=stack.updated_at, user_creds_id=stack.user_creds_id, tenant_id=stack.tenant, validate_parameters=False) return stack def store(self, backup=False): ''' Store the stack in the database and return its ID If self.id is set, we update the existing stack ''' s = { 'name': self._backup_name() if backup else self.name, 'raw_template_id': self.t.store(self.context), 'parameters': self.env.user_env_as_dict(), 'owner_id': self.owner_id, 'username': self.context.username, 'tenant': self.tenant_id, 'action': self.action, 'status': self.status, 'status_reason': self.status_reason, 'timeout': self.timeout_mins, 'disable_rollback': self.disable_rollback, 'stack_user_project_id': self.stack_user_project_id, 'updated_at': self.updated_time, 'user_creds_id': self.user_creds_id } if self.id: db_api.stack_update(self.context, self.id, s) else: # Create a context containing a trust_id and trustor_user_id # if trusts are enabled if cfg.CONF.deferred_auth_method == 'trusts': trust_context = self.clients.keystone().create_trust_context() new_creds = db_api.user_creds_create(trust_context) else: new_creds = db_api.user_creds_create(self.context) s['user_creds_id'] = new_creds.id self.user_creds_id = new_creds.id new_s = db_api.stack_create(self.context, s) self.id = new_s.id self.created_time = new_s.created_at self._set_param_stackid() return self.id def _backup_name(self): return '%s*' % self.name def identifier(self): ''' Return an identifier for this stack. ''' return identifier.HeatIdentifier(self.tenant_id, self.name, self.id) def __iter__(self): ''' Return an iterator over the resource names. ''' return iter(self.resources) def __len__(self): '''Return the number of resources.''' return len(self.resources) def __getitem__(self, key): '''Get the resource with the specified name.''' return self.resources[key] def __setitem__(self, key, resource): '''Set the resource with the specified name to a specific value.''' resource.stack = self resource.reparse() self.resources[key] = resource def __delitem__(self, key): '''Remove the resource with the specified name.''' del self.resources[key] def __contains__(self, key): '''Determine whether the stack contains the specified resource.''' if self._resources is not None: return key in self.resources else: return key in self.t[self.t.RESOURCES] def __eq__(self, other): ''' Compare two Stacks for equality. Stacks are considered equal only if they are identical. ''' return self is other def __str__(self): '''Return a human-readable string representation of the stack.''' return 'Stack "%s" [%s]' % (self.name, self.id) def resource_by_refid(self, refid): ''' Return the resource in this stack with the specified refid, or None if not found ''' for r in self.values(): if r.state in ( (r.INIT, r.COMPLETE), (r.CREATE, r.IN_PROGRESS), (r.CREATE, r.COMPLETE), (r.RESUME, r.IN_PROGRESS), (r.RESUME, r.COMPLETE), (r.UPDATE, r.IN_PROGRESS), (r.UPDATE, r.COMPLETE)) and r.FnGetRefId() == refid: return r def register_access_allowed_handler(self, credential_id, handler): ''' Register a function which determines whether the credentials with a give ID can have access to a named resource. ''' assert callable(handler), 'Handler is not callable' self._access_allowed_handlers[credential_id] = handler def access_allowed(self, credential_id, resource_name): ''' Returns True if the credential_id is authorised to access the resource with the specified resource_name. ''' if not self.resources: # this also triggers lazy-loading of resources # so is required for register_access_allowed_handler # to be called return False handler = self._access_allowed_handlers.get(credential_id) return handler and handler(resource_name) def validate(self): ''' Validates the template. ''' # TODO(sdake) Should return line number of invalid reference # validate overall template (top-level structure) self.t.validate() # Validate Parameter Groups parameter_groups = ParameterGroups(self.t) parameter_groups.validate() # Check duplicate names between parameters and resources dup_names = set(self.parameters.keys()) & set(self.keys()) if dup_names: logger.debug(_("Duplicate names %s") % dup_names) raise StackValidationFailed(message=_("Duplicate names %s") % dup_names) for res in self.dependencies: try: result = res.validate() except exception.Error as ex: logger.exception(ex) raise ex except Exception as ex: logger.exception(ex) raise StackValidationFailed(message=strutils.safe_decode( six.text_type(ex))) if result: raise StackValidationFailed(message=result) def requires_deferred_auth(self): ''' Returns whether this stack may need to perform API requests during its lifecycle using the configured deferred authentication method. ''' return any(res.requires_deferred_auth for res in self.values()) def state_set(self, action, status, reason): '''Update the stack state in the database.''' if action not in self.ACTIONS: raise ValueError(_("Invalid action %s") % action) if status not in self.STATUSES: raise ValueError(_("Invalid status %s") % status) self.action = action self.status = status self.status_reason = reason if self.id is None: return stack = db_api.stack_get(self.context, self.id) if stack is not None: stack.update_and_save({'action': action, 'status': status, 'status_reason': reason}) notification.send(self) @property def state(self): '''Returns state, tuple of action, status.''' return (self.action, self.status) def timeout_secs(self): ''' Return the stack action timeout in seconds. ''' if self.timeout_mins is None: return cfg.CONF.stack_action_timeout return self.timeout_mins * 60 def preview_resources(self): ''' Preview the stack with all of the resources. ''' return [resource.preview() for resource in self.resources.itervalues()] def create(self): ''' Create the stack and all of the resources. ''' def rollback(): if not self.disable_rollback and self.state == (self.CREATE, self.FAILED): self.delete(action=self.ROLLBACK) creator = scheduler.TaskRunner(self.stack_task, action=self.CREATE, reverse=False, post_func=rollback) creator(timeout=self.timeout_secs()) def _adopt_kwargs(self, resource): data = self.adopt_stack_data if not data or not data.get('resources'): return {'resource_data': None} return {'resource_data': data['resources'].get(resource.name)} @scheduler.wrappertask def stack_task(self, action, reverse=False, post_func=None): ''' A task to perform an action on the stack and all of the resources in forward or reverse dependency order as specfifed by reverse ''' self.state_set(action, self.IN_PROGRESS, 'Stack %s started' % action) stack_status = self.COMPLETE reason = 'Stack %s completed successfully' % action def resource_action(r): # Find e.g resource.create and call it action_l = action.lower() handle = getattr(r, '%s' % action_l) # If a local _$action_kwargs function exists, call it to get the # action specific argument list, otherwise an empty arg list handle_kwargs = getattr(self, '_%s_kwargs' % action_l, lambda x: {}) return handle(**handle_kwargs(r)) action_task = scheduler.DependencyTaskGroup(self.dependencies, resource_action, reverse) try: yield action_task() except exception.ResourceFailure as ex: stack_status = self.FAILED reason = 'Resource %s failed: %s' % (action, str(ex)) except scheduler.Timeout: stack_status = self.FAILED reason = '%s timed out' % action.title() self.state_set(action, stack_status, reason) if callable(post_func): post_func() def _backup_stack(self, create_if_missing=True): ''' Get a Stack containing any in-progress resources from the previous stack state prior to an update. ''' s = db_api.stack_get_by_name_and_owner_id(self.context, self._backup_name(), owner_id=self.id) if s is not None: logger.debug(_('Loaded existing backup stack')) return self.load(self.context, stack=s) elif create_if_missing: templ = Template.load(self.context, self.t.id) templ.files = copy.deepcopy(self.t.files) prev = type(self)(self.context, self.name, templ, self.env, owner_id=self.id) prev.store(backup=True) logger.debug(_('Created new backup stack')) return prev else: return None def adopt(self): ''' Adopt a stack (create stack with all the existing resources). ''' def rollback(): if not self.disable_rollback and self.state == (self.ADOPT, self.FAILED): self.delete(action=self.ROLLBACK) creator = scheduler.TaskRunner( self.stack_task, action=self.ADOPT, reverse=False, post_func=rollback) creator(timeout=self.timeout_secs()) def update(self, newstack): ''' Compare the current stack with newstack, and where necessary create/update/delete the resources until this stack aligns with newstack. Note update of existing stack resources depends on update being implemented in the underlying resource types Update will fail if it exceeds the specified timeout. The default is 60 minutes, set in the constructor ''' self.updated_time = datetime.utcnow() updater = scheduler.TaskRunner(self.update_task, newstack) updater() @scheduler.wrappertask def update_task(self, newstack, action=UPDATE): if action not in (self.UPDATE, self.ROLLBACK): logger.error(_("Unexpected action %s passed to update!") % action) self.state_set(self.UPDATE, self.FAILED, "Invalid action %s" % action) return if self.status != self.COMPLETE: if (action == self.ROLLBACK and self.state == (self.UPDATE, self.IN_PROGRESS)): logger.debug(_("Starting update rollback for %s") % self.name) else: self.state_set(action, self.FAILED, 'State invalid for %s' % action) return self.state_set(self.UPDATE, self.IN_PROGRESS, 'Stack %s started' % action) oldstack = Stack(self.context, self.name, self.t, self.env) backup_stack = self._backup_stack() try: update_task = update.StackUpdate(self, newstack, backup_stack, rollback=action == self.ROLLBACK) updater = scheduler.TaskRunner(update_task) self.env = newstack.env self.parameters = newstack.parameters self.t.files = newstack.t.files self.disable_rollback = newstack.disable_rollback self.timeout_mins = newstack.timeout_mins self._set_param_stackid() try: updater.start(timeout=self.timeout_secs()) yield while not updater.step(): yield finally: self.reset_dependencies() if action == self.UPDATE: reason = 'Stack successfully updated' else: reason = 'Stack rollback completed' stack_status = self.COMPLETE except scheduler.Timeout: stack_status = self.FAILED reason = 'Timed out' except exception.ResourceFailure as e: reason = str(e) stack_status = self.FAILED if action == self.UPDATE: # If rollback is enabled, we do another update, with the # existing template, so we roll back to the original state if not self.disable_rollback: yield self.update_task(oldstack, action=self.ROLLBACK) return else: logger.debug(_('Deleting backup stack')) backup_stack.delete(backup=True) self.state_set(action, stack_status, reason) # flip the template to the newstack values # Note we do this on success and failure, so the current # stack resources are stored, even if one is in a failed # state (otherwise we won't remove them on delete) self.t = newstack.t template_outputs = self.t[self.t.OUTPUTS] self.outputs = self.resolve_static_data(template_outputs) self.store() def delete(self, action=DELETE, backup=False): ''' Delete all of the resources, and then the stack itself. The action parameter is used to differentiate between a user initiated delete and an automatic stack rollback after a failed create, which amount to the same thing, but the states are recorded differently. ''' if action not in (self.DELETE, self.ROLLBACK): logger.error(_("Unexpected action %s passed to delete!") % action) self.state_set(self.DELETE, self.FAILED, "Invalid action %s" % action) return stack_status = self.COMPLETE reason = 'Stack %s completed successfully' % action self.state_set(action, self.IN_PROGRESS, 'Stack %s started' % action) backup_stack = self._backup_stack(False) if backup_stack is not None: backup_stack.delete(backup=True) if backup_stack.status != backup_stack.COMPLETE: errs = backup_stack.status_reason failure = 'Error deleting backup resources: %s' % errs self.state_set(action, self.FAILED, 'Failed to %s : %s' % (action, failure)) return action_task = scheduler.DependencyTaskGroup(self.dependencies, resource.Resource.destroy, reverse=True) try: scheduler.TaskRunner(action_task)(timeout=self.timeout_secs()) except exception.ResourceFailure as ex: stack_status = self.FAILED reason = 'Resource %s failed: %s' % (action, str(ex)) except scheduler.Timeout: stack_status = self.FAILED reason = '%s timed out' % action.title() if stack_status != self.FAILED and not backup: # Cleanup stored user_creds so they aren't accessible via # the soft-deleted stack which remains in the DB if self.user_creds_id: user_creds = db_api.user_creds_get(self.user_creds_id) # If we created a trust, delete it trust_id = user_creds.get('trust_id') if trust_id: try: self.clients.keystone().delete_trust(trust_id) except Exception as ex: logger.exception(ex) stack_status = self.FAILED reason = "Error deleting trust: %s" % str(ex) # Delete the stored credentials db_api.user_creds_delete(self.context, self.user_creds_id) self.user_creds_id = None self.store() # If the stack has a domain project, delete it if self.stack_user_project_id: try: self.clients.keystone().delete_stack_domain_project( project_id=self.stack_user_project_id) except Exception as ex: logger.exception(ex) stack_status = self.FAILED reason = "Error deleting project: %s" % str(ex) self.state_set(action, stack_status, reason) if stack_status != self.FAILED: # delete the stack db_api.stack_delete(self.context, self.id) self.id = None def suspend(self): ''' Suspend the stack, which invokes handle_suspend for all stack resources waits for all resources to become SUSPEND_COMPLETE then declares the stack SUSPEND_COMPLETE. Note the default implementation for all resources is to do nothing other than move to SUSPEND_COMPLETE, so the resources must implement handle_suspend for this to have any effect. ''' # No need to suspend if the stack has been suspended if self.state == (self.SUSPEND, self.COMPLETE): logger.info(_('%s is already suspended') % str(self)) return sus_task = scheduler.TaskRunner(self.stack_task, action=self.SUSPEND, reverse=True) sus_task(timeout=self.timeout_secs()) def resume(self): ''' Resume the stack, which invokes handle_resume for all stack resources waits for all resources to become RESUME_COMPLETE then declares the stack RESUME_COMPLETE. Note the default implementation for all resources is to do nothing other than move to RESUME_COMPLETE, so the resources must implement handle_resume for this to have any effect. ''' # No need to resume if the stack has been resumed if self.state == (self.RESUME, self.COMPLETE): logger.info(_('%s is already resumed') % str(self)) return sus_task = scheduler.TaskRunner(self.stack_task, action=self.RESUME, reverse=False) sus_task(timeout=self.timeout_secs()) def output(self, key): ''' Get the value of the specified stack output. ''' value = self.outputs[key].get('Value', '') return self.resolve_runtime_data(value) def restart_resource(self, resource_name): ''' stop resource_name and all that depend on it start resource_name and all that depend on it ''' deps = self.dependencies[self[resource_name]] failed = False for res in reversed(deps): try: scheduler.TaskRunner(res.destroy)() except exception.ResourceFailure as ex: failed = True logger.error(_('delete: %s') % str(ex)) for res in deps: if not failed: try: res.state_reset() scheduler.TaskRunner(res.create)() except exception.ResourceFailure as ex: logger.exception(_('create')) failed = True else: res.state_set(res.CREATE, res.FAILED, 'Resource restart aborted') # TODO(asalkeld) if any of this fails we Should # restart the whole stack def get_availability_zones(self): if self._zones is None: self._zones = [ zone.zoneName for zone in self.clients.nova().availability_zones.list(detailed=False)] return self._zones def set_deletion_policy(self, policy): for res in self.resources.values(): res.set_deletion_policy(policy) def set_stack_user_project_id(self, project_id): self.stack_user_project_id = project_id self.store() def get_abandon_data(self): return { 'name': self.name, 'id': self.id, 'action': self.action, 'status': self.status, 'template': self.t.t, 'resources': dict((res.name, res.get_abandon_data()) for res in self.resources.values()) } def resolve_static_data(self, snippet): return self.t.parse(self, snippet) def resolve_runtime_data(self, snippet): return function.resolve(snippet) heat-2014.1.5/heat/engine/stack_resource.py0000664000567000056700000003250212540642614021607 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. from oslo.config import cfg from heat.common import exception from heat.engine import attributes from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) class StackResource(resource.Resource): ''' An abstract Resource subclass that allows the management of an entire Stack as a resource in a parent stack. ''' # Assume True as this is evaluated before the stack is created # so there is no way to know for sure without subclass-specific # template parsing. requires_deferred_auth = True def __init__(self, name, json_snippet, stack): super(StackResource, self).__init__(name, json_snippet, stack) self._nested = None if self.stack.parent_resource: self.recursion_depth = ( self.stack.parent_resource.recursion_depth + 1) else: self.recursion_depth = 0 def _outputs_to_attribs(self, json_snippet): if not self.attributes and 'Outputs' in json_snippet: self.attributes_schema = ( attributes.Attributes .schema_from_outputs(json_snippet.get('Outputs'))) self.attributes = attributes.Attributes(self.name, self.attributes_schema, self._resolve_attribute) def nested(self): ''' Return a Stack object representing the nested (child) stack. ''' if self._nested is None and self.resource_id is not None: self._nested = parser.Stack.load(self.context, self.resource_id, parent_resource=self, show_deleted=False) if self._nested is None: raise exception.NotFound(_("Nested stack not found in DB")) return self._nested def child_template(self): ''' Default implementation to get the child template. Resources that inherit from StackResource should override this method with specific details about the template used by them. ''' raise NotImplementedError() def child_params(self): ''' Default implementation to get the child params. Resources that inherit from StackResource should override this method with specific details about the parameters used by them. ''' raise NotImplementedError() def preview(self): ''' Preview a StackResource as resources within a Stack. This method overrides the original Resource.preview to return a preview of all the resources contained in this Stack. For this to be possible, the specific resources need to override both ``child_template`` and ``child_params`` with specific information to allow the stack to be parsed correctly. If any of these methods is missing, the entire StackResource will be returned as if it were a regular Resource. ''' try: template = parser.Template(self.child_template()) params = self.child_params() except NotImplementedError: not_implemented_msg = _("Preview of '%s' not yet implemented") logger.warning(not_implemented_msg % self.__class__.__name__) return self self._validate_nested_resources(template) name = "%s-%s" % (self.stack.name, self.name) nested = parser.Stack(self.context, name, template, self._nested_environment(params), disable_rollback=True, parent_resource=self, owner_id=self.stack.id) return nested.preview_resources() def _validate_nested_resources(self, template): total_resources = (len(template[template.RESOURCES]) + self.stack.root_stack.total_resources()) if (total_resources > cfg.CONF.max_resources_per_stack): message = exception.StackResourceLimitExceeded.msg_fmt raise exception.RequestLimitExceeded(message=message) def _nested_environment(self, user_params): """Build a sensible environment for the nested stack. This is built from the user_params and the parent stack's registry so we can use user-defined resources within nested stacks. """ nested_env = environment.Environment() nested_env.registry = self.stack.env.registry user_env = {environment.PARAMETERS: {}} if user_params is not None: if environment.PARAMETERS not in user_params: user_env[environment.PARAMETERS] = user_params else: user_env.update(user_params) nested_env.load(user_env) return nested_env def create_with_template(self, child_template, user_params, timeout_mins=None, adopt_data=None): ''' Handle the creation of the nested stack from a given JSON template. ''' if self.recursion_depth >= cfg.CONF.max_nested_stack_depth: msg = _("Recursion depth exceeds %d.") % \ cfg.CONF.max_nested_stack_depth raise exception.RequestLimitExceeded(message=msg) template = parser.Template(child_template, files=self.stack.t.files) self._validate_nested_resources(template) self._outputs_to_attribs(child_template) if timeout_mins is None: timeout_mins = self.stack.timeout_mins # Note we disable rollback for nested stacks, since they # should be rolled back by the parent stack on failure nested = parser.Stack(self.context, self.physical_resource_name(), template, self._nested_environment(user_params), timeout_mins=timeout_mins, disable_rollback=True, parent_resource=self, owner_id=self.stack.id, adopt_stack_data=adopt_data) nested.validate() self._nested = nested nested_id = self._nested.store() self.resource_id_set(nested_id) action = self._nested.CREATE if adopt_data: action = self._nested.ADOPT stack_creator = scheduler.TaskRunner(self._nested.stack_task, action=action) stack_creator.start(timeout=self._nested.timeout_secs()) return stack_creator def check_create_complete(self, stack_creator): done = stack_creator.step() if done: if self._nested.state != (self._nested.CREATE, self._nested.COMPLETE): raise exception.Error(self._nested.status_reason) return done def update_with_template(self, child_template, user_params, timeout_mins=None): """Update the nested stack with the new template.""" template = parser.Template(child_template, files=self.stack.t.files) # Note that there is no call to self._outputs_to_attribs here. # If we have a use case for updating attributes of the resource based # on updated templates we should make sure it's optional because not # all subclasses want that behavior, since they may offer custom # attributes. nested_stack = self.nested() if nested_stack is None: raise exception.Error(_('Cannot update %s, stack not created') % self.name) res_diff = ( len(template[template.RESOURCES]) - len(nested_stack.resources)) new_size = nested_stack.root_stack.total_resources() + res_diff if new_size > cfg.CONF.max_resources_per_stack: raise exception.RequestLimitExceeded( message=exception.StackResourceLimitExceeded.msg_fmt) if timeout_mins is None: timeout_mins = self.stack.timeout_mins # Note we disable rollback for nested stacks, since they # should be rolled back by the parent stack on failure stack = parser.Stack(self.context, self.physical_resource_name(), template, self._nested_environment(user_params), timeout_mins=timeout_mins, disable_rollback=True, parent_resource=self, owner_id=self.stack.id) stack.parameters.set_stack_id(nested_stack.identifier()) stack.validate() if not hasattr(type(self), 'attributes_schema'): self.attributes = None self._outputs_to_attribs(child_template) updater = scheduler.TaskRunner(nested_stack.update_task, stack) updater.start() return updater def check_update_complete(self, updater): if updater is None: return True if not updater.step(): return False nested_stack = self.nested() if nested_stack.state != (nested_stack.UPDATE, nested_stack.COMPLETE): raise exception.Error(_("Nested stack UPDATE failed: %s") % nested_stack.status_reason) return True def delete_nested(self): ''' Delete the nested stack. ''' try: stack = self.nested() except exception.NotFound: logger.info(_("Stack not found to delete")) else: if stack is not None: delete_task = scheduler.TaskRunner(stack.delete) delete_task.start() return delete_task def check_delete_complete(self, delete_task): if delete_task is None: return True done = delete_task.step() if done: nested_stack = self.nested() if nested_stack.state != (nested_stack.DELETE, nested_stack.COMPLETE): raise exception.Error(nested_stack.status_reason) return done def handle_suspend(self): stack = self.nested() if stack is None: raise exception.Error(_('Cannot suspend %s, stack not created') % self.name) suspend_task = scheduler.TaskRunner(self._nested.stack_task, action=self._nested.SUSPEND, reverse=True) suspend_task.start(timeout=self._nested.timeout_secs()) return suspend_task def check_suspend_complete(self, suspend_task): done = suspend_task.step() if done: if self._nested.state != (self._nested.SUSPEND, self._nested.COMPLETE): raise exception.Error(self._nested.status_reason) return done def handle_resume(self): stack = self.nested() if stack is None: raise exception.Error(_('Cannot resume %s, stack not created') % self.name) resume_task = scheduler.TaskRunner(self._nested.stack_task, action=self._nested.RESUME, reverse=False) resume_task.start(timeout=self._nested.timeout_secs()) return resume_task def check_resume_complete(self, resume_task): done = resume_task.step() if done: if self._nested.state != (self._nested.RESUME, self._nested.COMPLETE): raise exception.Error(self._nested.status_reason) return done def set_deletion_policy(self, policy): self.nested().set_deletion_policy(policy) def get_abandon_data(self): return self.nested().get_abandon_data() def get_output(self, op): ''' Return the specified Output value from the nested stack. If the output key does not exist, raise an InvalidTemplateAttribute exception. ''' stack = self.nested() if stack is None: return None if op not in stack.outputs: raise exception.InvalidTemplateAttribute(resource=self.name, key=op) return stack.output(op) def _resolve_attribute(self, name): return unicode(self.get_output(name)) heat-2014.1.5/heat/engine/stack_user.py0000664000567000056700000001413312540642614020736 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. import keystoneclient.exceptions as kc_exception from heat.db import api as db_api from heat.common import exception from heat.engine import resource from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) class StackUser(resource.Resource): # Subclasses create a user, and optionally keypair associated with a # resource in a stack. Users are created in the heat stack user domain # (in a project specific to the stack) def __init__(self, name, json_snippet, stack): super(StackUser, self).__init__(name, json_snippet, stack) self.password = None def handle_create(self): self._create_user() def _create_user(self): # Check for stack user project, create if not yet set if not self.stack.stack_user_project_id: project_id = self.keystone().create_stack_domain_project( self.stack.id) self.stack.set_stack_user_project_id(project_id) # Create a keystone user in the stack domain project user_id = self.keystone().create_stack_domain_user( username=self.physical_resource_name(), password=self.password, project_id=self.stack.stack_user_project_id) # Store the ID in resource data, for compatibility with SignalResponder db_api.resource_data_set(self, 'user_id', user_id) def _get_user_id(self): try: return db_api.resource_data_get(self, 'user_id') except exception.NotFound: # FIXME(shardy): This is a legacy hack for backwards compatibility # remove after an appropriate transitional period... # Assume this is a resource that was created with # a previous version of heat and that the resource_id # is the user_id if self.resource_id: db_api.resource_data_set(self, 'user_id', self.resource_id) return self.resource_id def handle_delete(self): self._delete_user() def _delete_user(self): user_id = self._get_user_id() if user_id is None: return try: self.keystone().delete_stack_domain_user( user_id=user_id, project_id=self.stack.stack_user_project_id) except kc_exception.NotFound: pass except ValueError: # FIXME(shardy): This is a legacy delete path for backwards # compatibility with resources created before the migration # to stack_user.StackUser domain users. After an appropriate # transitional period, this should be removed. logger.warning(_('Reverting to legacy user delete path')) try: self.keystone().delete_stack_user(user_id) except kc_exception.NotFound: pass for data_key in ('credential_id', 'access_key', 'secret_key'): try: db_api.resource_data_delete(self, data_key) except exception.NotFound: pass def handle_suspend(self): user_id = self._get_user_id() try: self.keystone().disable_stack_domain_user( user_id=user_id, project_id=self.stack.stack_user_project_id) except ValueError: # FIXME(shardy): This is a legacy path for backwards compatibility self.keystone().disable_stack_user(user_id=user_id) def handle_resume(self): user_id = self._get_user_id() try: self.keystone().enable_stack_domain_user( user_id=user_id, project_id=self.stack.stack_user_project_id) except ValueError: # FIXME(shardy): This is a legacy path for backwards compatibility self.keystone().enable_stack_user(user_id=user_id) def _create_keypair(self): # Subclasses may optionally call this in handle_create to create # an ec2 keypair associated with the user, the resulting keys are # stored in resource_data user_id = self._get_user_id() kp = self.keystone().create_stack_domain_user_keypair( user_id=user_id, project_id=self.stack.stack_user_project_id) if not kp: raise exception.Error(_("Error creating ec2 keypair for user %s") % user_id) else: db_api.resource_data_set(self, 'credential_id', kp.id, redact=True) db_api.resource_data_set(self, 'access_key', kp.access, redact=True) db_api.resource_data_set(self, 'secret_key', kp.secret, redact=True) return kp def _delete_keypair(self): # Subclasses may optionally call this to delete a keypair created # via _create_keypair user_id = self._get_user_id() try: credential_id = db_api.resource_data_get(self, 'credential_id') except exception.NotFound: return try: self.keystone().delete_stack_domain_user_keypair( user_id=user_id, project_id=self.stack.stack_user_project_id, credential_id=credential_id) except ValueError: self.keystone().delete_ec2_keypair( user_id=user_id, credential_id=credential_id) for data_key in ('access_key', 'secret_key', 'credential_id'): try: db_api.resource_data_delete(self, data_key) except exception.NotFound: pass heat-2014.1.5/heat/engine/support.py0000664000567000056700000000254312540642614020311 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. SUPPORT_STATUSES = (UNKNOWN, SUPPORTED, PROTOTYPE, DEPRECATED, UNSUPPORTED) = ('UNKNOWN', 'SUPPORTED', 'PROTOTYPE', 'DEPRECATED', 'UNSUPPORTED') class SupportStatus(object): def __init__(self, status=SUPPORTED, message=None, version=None): if status in SUPPORT_STATUSES: self.status = status self.message = message self.version = version else: self.status = UNKNOWN self.message = _("Specified status is invalid, defaulting to" " %s") % UNKNOWN self.version = None def to_dict(self): return {'status': self.status, 'message': self.message, 'version': self.version} heat-2014.1.5/heat/engine/parameters.py0000664000567000056700000004154312540642614020743 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. import collections import itertools import json import six from heat.engine import constraints as constr from heat.common import exception from heat.openstack.common import strutils PARAMETER_KEYS = ( TYPE, DEFAULT, NO_ECHO, ALLOWED_VALUES, ALLOWED_PATTERN, MAX_LENGTH, MIN_LENGTH, MAX_VALUE, MIN_VALUE, DESCRIPTION, CONSTRAINT_DESCRIPTION, LABEL ) = ( 'Type', 'Default', 'NoEcho', 'AllowedValues', 'AllowedPattern', 'MaxLength', 'MinLength', 'MaxValue', 'MinValue', 'Description', 'ConstraintDescription', 'Label' ) class Schema(constr.Schema): '''Parameter schema.''' KEYS = ( TYPE, DESCRIPTION, DEFAULT, SCHEMA, CONSTRAINTS, HIDDEN, LABEL ) = ( 'Type', 'Description', 'Default', 'Schema', 'Constraints', 'NoEcho', 'Label' ) PARAMETER_KEYS = PARAMETER_KEYS # For Parameters the type name for Schema.LIST is CommaDelimitedList # and the type name for Schema.MAP is Json TYPES = ( STRING, NUMBER, LIST, MAP, ) = ( 'String', 'Number', 'CommaDelimitedList', 'Json', ) def __init__(self, data_type, description=None, default=None, schema=None, constraints=[], hidden=False, label=None): super(Schema, self).__init__(data_type=data_type, description=description, default=default, schema=schema, required=default is None, constraints=constraints, label=label) self.hidden = hidden # Schema class validates default value for lists assuming list type. For # comma delimited list string supported in paramaters Schema class, the # default value has to be parsed into a list if necessary so that # validation works. def _validate_default(self, context): if self.default is not None: default_value = self.default if self.type == self.LIST and not isinstance(self.default, list): try: default_value = self.default.split(',') except (KeyError, AttributeError) as err: raise constr.InvalidSchemaError(_('Default must be a ' 'comma-delimited list ' 'string: %s') % str(err)) try: self.validate_constraints(default_value, context) except (ValueError, TypeError) as exc: raise constr.InvalidSchemaError(_('Invalid default ' '%(default)s (%(exc)s)') % dict(default=self.default, exc=exc)) def set_default(self, default=None): super(Schema, self).set_default(default) self.required = default is None @staticmethod def get_num(key, context): val = context.get(key) if val is not None: val = Schema.str_to_num(val) return val @staticmethod def _check_dict(schema_dict, allowed_keys, entity): if not isinstance(schema_dict, dict): raise constr.InvalidSchemaError( _("Invalid %s, expected a mapping") % entity) for key in schema_dict: if key not in allowed_keys: raise constr.InvalidSchemaError( _("Invalid key '%(key)s' for %(entity)s") % { "key": key, "entity": entity}) @classmethod def _validate_dict(cls, schema_dict): cls._check_dict(schema_dict, cls.PARAMETER_KEYS, "parameter") if cls.TYPE not in schema_dict: raise constr.InvalidSchemaError(_("Missing parameter type")) @classmethod def from_dict(cls, schema_dict): """ Return a Parameter Schema object from a legacy schema dictionary. """ cls._validate_dict(schema_dict) def constraints(): desc = schema_dict.get(CONSTRAINT_DESCRIPTION) if MIN_VALUE in schema_dict or MAX_VALUE in schema_dict: yield constr.Range(Schema.get_num(MIN_VALUE, schema_dict), Schema.get_num(MAX_VALUE, schema_dict), desc) if MIN_LENGTH in schema_dict or MAX_LENGTH in schema_dict: yield constr.Length(Schema.get_num(MIN_LENGTH, schema_dict), Schema.get_num(MAX_LENGTH, schema_dict), desc) if ALLOWED_VALUES in schema_dict: yield constr.AllowedValues(schema_dict[ALLOWED_VALUES], desc) if ALLOWED_PATTERN in schema_dict: yield constr.AllowedPattern(schema_dict[ALLOWED_PATTERN], desc) # make update_allowed true by default on TemplateResources # as the template should deal with this. return cls(schema_dict[TYPE], description=schema_dict.get(DESCRIPTION), default=schema_dict.get(DEFAULT), constraints=list(constraints()), hidden=str(schema_dict.get(NO_ECHO, 'false')).lower() == 'true', label=schema_dict.get(LABEL)) def validate_value(self, name, value, context=None): super(Schema, self).validate_constraints(value, context) def __getitem__(self, key): if key == self.TYPE: return self.type if key == self.HIDDEN: return self.hidden else: return super(Schema, self).__getitem__(key) raise KeyError(key) class Parameter(object): '''A template parameter.''' def __new__(cls, name, schema, value=None): '''Create a new Parameter of the appropriate type.''' if cls is not Parameter: return super(Parameter, cls).__new__(cls) # Check for fully-fledged Schema objects if not isinstance(schema, Schema): schema = Schema.from_dict(schema) if schema.type == schema.STRING: ParamClass = StringParam elif schema.type == schema.NUMBER: ParamClass = NumberParam elif schema.type == schema.LIST: ParamClass = CommaDelimitedListParam elif schema.type == schema.MAP: ParamClass = JsonParam else: raise ValueError(_('Invalid Parameter type "%s"') % schema.type) return ParamClass(name, schema, value) def __init__(self, name, schema, value=None): ''' Initialise the Parameter with a name, schema and optional user-supplied value. ''' self.name = name self.schema = schema self.user_value = value def validate(self, validate_value=True, context=None): ''' Validates the parameter. This method validates if the parameter's schema is valid, and if the default value - if present - or the user-provided value for the parameter comply with the schema. ''' self.schema.validate(context) if validate_value: if self.has_default(): self._validate(self.default(), context) if self.user_value is not None: self._validate(self.user_value, context) elif not self.has_default(): raise exception.UserParameterMissing(key=self.name) def value(self): '''Get the parameter value, optionally sanitising it for output.''' if self.user_value is not None: return self.user_value if self.has_default(): return self.default() raise KeyError(_('Missing parameter %s') % self.name) def has_value(self): '''Parameter has a user or default value.''' return self.user_value or self.has_default() def hidden(self): ''' Return whether the parameter should be sanitised in any output to the user. ''' return self.schema.hidden def description(self): '''Return the description of the parameter.''' return self.schema.description or '' def label(self): '''Return the label or param name.''' return self.schema.label or self.name def has_default(self): '''Return whether the parameter has a default value.''' return self.schema.default is not None def default(self): '''Return the default value of the parameter.''' return self.schema.default def __str__(self): '''Return a string representation of the parameter''' value = self.value() if self.hidden(): return '******' else: return strutils.safe_encode(six.text_type(value)) class NumberParam(Parameter): '''A template parameter of type "Number".''' def __int__(self): '''Return an integer representation of the parameter''' return int(super(NumberParam, self).value()) def __float__(self): '''Return a float representation of the parameter''' return float(super(NumberParam, self).value()) def _validate(self, val, context): self.schema.validate_value(self.name, val, context) def value(self): try: return int(self) except ValueError: return float(self) class StringParam(Parameter): '''A template parameter of type "String".''' def _validate(self, val, context): self.schema.validate_value(self.name, val, context) class CommaDelimitedListParam(Parameter, collections.Sequence): '''A template parameter of type "CommaDelimitedList".''' def __init__(self, name, schema, value=None): super(CommaDelimitedListParam, self).__init__(name, schema, value) self.parsed = self.parse(self.user_value or self.default()) def parse(self, value): # only parse when value is not already a list if isinstance(value, list): return value try: if value: return value.split(',') except (KeyError, AttributeError) as err: message = _('Value must be a comma-delimited list string: %s') raise ValueError(message % str(err)) return value def value(self): return self.parsed def __len__(self): '''Return the length of the list.''' return len(self.parsed) def __getitem__(self, index): '''Return an item from the list.''' return self.parsed[index] def _validate(self, val, context): parsed = self.parse(val) self.schema.validate_value(self.name, parsed, context) class JsonParam(Parameter, collections.Mapping): """A template parameter who's value is valid map.""" def __init__(self, name, schema, value=None): super(JsonParam, self).__init__(name, schema, value) self.parsed = self.parse(self.user_value or self.default()) def parse(self, value): try: val = value if isinstance(val, collections.Mapping): val = json.dumps(val) if val: return json.loads(val) except (ValueError, TypeError) as err: message = _('Value must be valid JSON: %s') % str(err) raise ValueError(message) return value def value(self): return self.parsed def __getitem__(self, key): return self.parsed[key] def __iter__(self): return iter(self.parsed) def __len__(self): return len(self.parsed) def _validate(self, val, context): val = self.parse(val) self.schema.validate_value(self.name, val, context) class Parameters(collections.Mapping): ''' The parameters of a stack, with type checking, defaults &c. specified by the stack's template. ''' PSEUDO_PARAMETERS = ( PARAM_STACK_ID, PARAM_STACK_NAME, PARAM_REGION ) = ( 'AWS::StackId', 'AWS::StackName', 'AWS::Region' ) def __init__(self, stack_identifier, tmpl, user_params={}): ''' Create the parameter container for a stack from the stack name and template, optionally setting the user-supplied parameter values. ''' def user_parameter(schema_item): name, schema = schema_item return Parameter(name, schema, user_params.get(name)) self.tmpl = tmpl self.user_params = user_params schemata = self.tmpl.param_schemata() user_parameters = (user_parameter(si) for si in schemata.iteritems()) pseudo_parameters = self._pseudo_parameters(stack_identifier) self.params = dict((p.name, p) for p in itertools.chain(pseudo_parameters, user_parameters)) def validate(self, validate_value=True, context=None): ''' Validates all parameters. This method validates if all user-provided parameters are actually defined in the template, and if all parameters are valid. ''' self._validate_tmpl_parameters() self._validate_user_parameters() for param in self.params.values(): param.validate(validate_value, context) def __contains__(self, key): '''Return whether the specified parameter exists.''' return key in self.params def __iter__(self): '''Return an iterator over the parameter names.''' return iter(self.params) def __len__(self): '''Return the number of parameters defined.''' return len(self.params) def __getitem__(self, key): '''Get a parameter value.''' return self.params[key].value() def map(self, func, filter_func=lambda p: True): ''' Map the supplied filter function onto each Parameter (with an optional filter function) and return the resulting dictionary. ''' return dict((n, func(p)) for n, p in self.params.iteritems() if filter_func(p)) def set_stack_id(self, stack_identifier): ''' Set the StackId pseudo parameter value ''' if stack_identifier is not None: self.params[self.PARAM_STACK_ID].schema.set_default( stack_identifier.arn()) return True return False def _validate_user_parameters(self): schemata = self.tmpl.param_schemata() for param in self.user_params: if param not in schemata: raise exception.UnknownUserParameter(key=param) def _validate_tmpl_parameters(self): param = None for key in self.tmpl.t.keys(): if key == 'Parameters' or key == 'parameters': param = key break if param is not None: template_params = self.tmpl.t[key] for name, attrs in template_params.iteritems(): if not isinstance(attrs, dict): raise exception.InvalidTemplateParameter(key=name) def _pseudo_parameters(self, stack_identifier): stack_id = stack_identifier.arn() \ if stack_identifier is not None else 'None' stack_name = stack_identifier and stack_identifier.stack_name yield Parameter(self.PARAM_STACK_ID, Schema(Schema.STRING, _('Stack ID'), default=str(stack_id))) if stack_name: yield Parameter(self.PARAM_STACK_NAME, Schema(Schema.STRING, _('Stack Name'), default=stack_name)) yield Parameter(self.PARAM_REGION, Schema(Schema.STRING, default='ap-southeast-1', constraints= [constr.AllowedValues(['us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1', 'eu-west-1', 'ap-southeast-1', 'ap-northeast-1'] )])) heat-2014.1.5/heat/engine/signal_responder.py0000664000567000056700000000760312540642614022135 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. from oslo.config import cfg from keystoneclient.contrib.ec2 import utils as ec2_utils from heat.db import api as db_api from heat.common import exception from heat.engine import stack_user from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ from heat.openstack.common.py3kcompat import urlutils logger = logging.getLogger(__name__) SIGNAL_TYPES = ( WAITCONDITION, SIGNAL ) = ( '/waitcondition', '/signal' ) SIGNAL_VERB = {WAITCONDITION: 'PUT', SIGNAL: 'POST'} class SignalResponder(stack_user.StackUser): # Anything which subclasses this may trigger authenticated # API operations as a consequence of handling a signal requires_deferred_auth = True def handle_create(self): super(SignalResponder, self).handle_create() self._create_keypair() def handle_delete(self): super(SignalResponder, self).handle_delete() self._delete_signed_url() def _delete_signed_url(self): try: db_api.resource_data_delete(self, 'ec2_signed_url') except exception.NotFound: pass def _get_signed_url(self, signal_type=SIGNAL): """Create properly formatted and pre-signed URL. This uses the created user for the credentials. See boto/auth.py::QuerySignatureV2AuthHandler :param signal_type: either WAITCONDITION or SIGNAL. """ try: stored = db_api.resource_data_get(self, 'ec2_signed_url') except exception.NotFound: stored = None if stored is not None: return stored try: access_key = db_api.resource_data_get(self, 'access_key') secret_key = db_api.resource_data_get(self, 'secret_key') except exception.NotFound: logger.warning(_('Cannot generate signed url, ' 'no stored access/secret key')) return waitcond_url = cfg.CONF.heat_waitcondition_server_url signal_url = waitcond_url.replace('/waitcondition', signal_type) host_url = urlutils.urlparse(signal_url) path = self.identifier().arn_url_path() # Note the WSGI spec apparently means that the webob request we end up # prcessing in the CFN API (ec2token.py) has an unquoted path, so we # need to calculate the signature with the path component unquoted, but # ensure the actual URL contains the quoted version... unquoted_path = urlutils.unquote(host_url.path + path) request = {'host': host_url.netloc.lower(), 'verb': SIGNAL_VERB[signal_type], 'path': unquoted_path, 'params': {'SignatureMethod': 'HmacSHA256', 'SignatureVersion': '2', 'AWSAccessKeyId': access_key, 'Timestamp': self.created_time.strftime("%Y-%m-%dT%H:%M:%SZ") }} # Sign the request signer = ec2_utils.Ec2Signer(secret_key) request['params']['Signature'] = signer.generate(request) qs = urlutils.urlencode(request['params']) url = "%s%s?%s" % (signal_url.lower(), path, qs) db_api.resource_data_set(self, 'ec2_signed_url', url) return url heat-2014.1.5/heat/engine/resource.py0000664000567000056700000010706612540642614020432 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. import base64 import copy from datetime import datetime from heat.engine import event from heat.common import exception from heat.openstack.common import excutils from heat.db import api as db_api from heat.common import identifier from heat.common import short_id from heat.engine import scheduler from heat.engine import resources from heat.engine import support # import class to avoid name collisions and ugly aliasing from heat.engine.attributes import Attributes from heat.engine import environment from heat.engine.properties import Properties from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) DELETION_POLICY = (DELETE, RETAIN, SNAPSHOT) = ('Delete', 'Retain', 'Snapshot') def get_types(support_status): '''Return a list of valid resource types.''' return resources.global_env().get_types(support_status) def get_class(resource_type, resource_name=None): '''Return the Resource class for a given resource type.''' return resources.global_env().get_class(resource_type, resource_name) def _register_class(resource_type, resource_class): resources.global_env().register_class(resource_type, resource_class) class UpdateReplace(Exception): ''' Raised when resource update requires replacement ''' _message = _("The Resource %s requires replacement.") def __init__(self, resource_name='Unknown', message=_("The Resource %s requires replacement.")): try: msg = message % resource_name except TypeError: msg = message super(Exception, self).__init__(msg) class Metadata(object): ''' A descriptor for accessing the metadata of a resource while ensuring the most up-to-date data is always obtained from the database. ''' def __get__(self, resource, resource_class): '''Return the metadata for the owning resource.''' if resource is None: return None if resource.id is None: return resource.parsed_template('Metadata') rs = db_api.resource_get(resource.stack.context, resource.id) rs.refresh(attrs=['rsrc_metadata']) return rs.rsrc_metadata def __set__(self, resource, metadata): '''Update the metadata for the owning resource.''' if resource.id is None: raise exception.ResourceNotAvailable(resource_name=resource.name) rs = db_api.resource_get(resource.stack.context, resource.id) rs.update_and_save({'rsrc_metadata': metadata}) class Resource(object): ACTIONS = (INIT, CREATE, DELETE, UPDATE, ROLLBACK, SUSPEND, RESUME, ADOPT ) = ('INIT', 'CREATE', 'DELETE', 'UPDATE', 'ROLLBACK', 'SUSPEND', 'RESUME', 'ADOPT') STATUSES = (IN_PROGRESS, FAILED, COMPLETE ) = ('IN_PROGRESS', 'FAILED', 'COMPLETE') # If True, this resource must be created before it can be referenced. strict_dependency = True _metadata = Metadata() # Resource implementation set this to the subset of template keys # which are supported for handle_update, used by update_template_diff update_allowed_keys = () # Resource implementation set this to the subset of resource properties # supported for handle_update, used by update_template_diff_properties update_allowed_properties = () # Resource implementations set this to the name: description dictionary # that describes the appropriate resource attributes attributes_schema = {} # If True, this resource may perform authenticated API requests # throughout its lifecycle requires_deferred_auth = False # Limit to apply to physical_resource_name() size reduction algorithm. # If set to None no limit will be applied. physical_resource_name_limit = 255 support_status = support.SupportStatus() def __new__(cls, name, json, stack): '''Create a new Resource of the appropriate class for its type.''' if cls != Resource: # Call is already for a subclass, so pass it through return super(Resource, cls).__new__(cls) from heat.engine.resources import template_resource # Select the correct subclass to instantiate. # Note: If the current stack is an implementation of # a resource type (a TemplateResource mapped in the environment) # then don't infinitely recurse by creating a child stack # of the same type. Instead get the next match which will get # us closer to a concrete class. def get_ancestor_template_resources(): """Return an ancestory list (TemplateResources only).""" parent = stack.parent_resource while parent is not None: if isinstance(parent, template_resource.TemplateResource): yield parent.template_name parent = parent.stack.parent_resource ancestor_list = set(get_ancestor_template_resources()) def accept_class(res_info): if not isinstance(res_info, environment.TemplateResourceInfo): return True return res_info.template_name not in ancestor_list ResourceClass = stack.env.registry.get_class(json.get('Type'), resource_name=name, accept_fn=accept_class) return ResourceClass(name, json, stack) def __init__(self, name, json_snippet, stack): if '/' in name: raise ValueError(_('Resource name may not contain "/"')) self.stack = stack self.context = stack.context self.name = name self.json_snippet = json_snippet self.reparse() self.attributes = Attributes(self.name, self.attributes_schema, self._resolve_attribute) if stack.id: resource = db_api.resource_get_by_name_and_stack(self.context, name, stack.id) else: resource = None if resource: self.resource_id = resource.nova_instance self.action = resource.action self.status = resource.status self.status_reason = resource.status_reason self.id = resource.id self.data = resource.data self.created_time = resource.created_at self.updated_time = resource.updated_at else: self.resource_id = None # if the stack is being deleted, assume we've already been deleted if stack.action == stack.DELETE: self.action = self.DELETE else: self.action = self.INIT self.status = self.COMPLETE self.status_reason = '' self.id = None self.data = [] self.created_time = None self.updated_time = None def reparse(self): self.t = self.stack.resolve_static_data(self.json_snippet) self.properties = Properties(self.properties_schema, self.t.get('Properties', {}), self._resolve_runtime_data, self.name, self.context) def __eq__(self, other): '''Allow == comparison of two resources.''' # For the purposes of comparison, we declare two resource objects # equal if their names and parsed_templates are the same if isinstance(other, Resource): return (self.name == other.name) and ( self.parsed_template() == other.parsed_template()) return NotImplemented def __ne__(self, other): '''Allow != comparison of two resources.''' result = self.__eq__(other) if result is NotImplemented: return result return not result @property def metadata(self): return self._metadata @metadata.setter def metadata(self, metadata): self._metadata = metadata def type(self): return self.t['Type'] def _resolve_runtime_data(self, snippet): return self.stack.resolve_runtime_data(snippet) def has_interface(self, resource_type): """Check to see if this resource is either mapped to resource_type or is a "resource_type". """ if self.type() == resource_type: return True ri = self.stack.env.get_resource_info(self.type(), self.name) return ri.name == resource_type def implementation_signature(self): ''' Return a tuple defining the implementation. This should be broken down into a definition and an implementation version. ''' return (self.__class__.__name__, self.support_status.version) def identifier(self): '''Return an identifier for this resource.''' return identifier.ResourceIdentifier(resource_name=self.name, **self.stack.identifier()) def parsed_template(self, section=None, default={}): ''' Return the parsed template data for the resource. May be limited to only one section of the data, in which case a default value may also be supplied. ''' if section is None: template = self.t else: template = self.t.get(section, default) return self._resolve_runtime_data(template) def update_template_diff(self, after, before): ''' Returns the difference between the before and after json snippets. If something has been removed in after which exists in before we set it to None. If any keys have changed which are not in update_allowed_keys, raises UpdateReplace if the differing keys are not in update_allowed_keys ''' update_allowed_set = set(self.update_allowed_keys) # Create a set containing the keys in both current and update template template_keys = set(before.keys()) template_keys.update(set(after.keys())) # Create a set of keys which differ (or are missing/added) changed_keys_set = set([k for k in template_keys if before.get(k) != after.get(k)]) if not changed_keys_set.issubset(update_allowed_set): raise UpdateReplace(self.name) return dict((k, after.get(k)) for k in changed_keys_set) def update_template_diff_properties(self, after, before): ''' Returns the changed Properties between the before and after json snippets. If a property has been removed in after which exists in before we set it to None. If any properties have changed which are not in update_allowed_properties, raises UpdateReplace if the modified properties are not in the update_allowed_properties ''' update_allowed_set = set(self.update_allowed_properties) for (psk, psv) in self.properties.props.iteritems(): if psv.update_allowed(): update_allowed_set.add(psk) # Create a set containing the keys in both current and update template current_properties = before.get('Properties', {}) template_properties = set(current_properties.keys()) updated_properties = after.get('Properties', {}) template_properties.update(set(updated_properties.keys())) # Create a set of keys which differ (or are missing/added) changed_properties_set = set(k for k in template_properties if current_properties.get(k) != updated_properties.get(k)) if not changed_properties_set.issubset(update_allowed_set): raise UpdateReplace(self.name) return dict((k, updated_properties.get(k)) for k in changed_properties_set) def __str__(self): if self.stack.id: if self.resource_id: return '%s "%s" [%s] %s' % (self.__class__.__name__, self.name, self.resource_id, str(self.stack)) return '%s "%s" %s' % (self.__class__.__name__, self.name, str(self.stack)) return '%s "%s"' % (self.__class__.__name__, self.name) def _add_dependencies(self, deps, path, fragment): if isinstance(fragment, dict): for key, value in fragment.items(): if key in ('DependsOn', 'Ref', 'Fn::GetAtt', 'get_attr', 'get_resource'): if key in ('Fn::GetAtt', 'get_attr'): res_name = value[0] res_list = [res_name] elif key == 'DependsOn' and isinstance(value, list): res_list = value else: res_list = [value] for res in res_list: try: target = self.stack[res] except KeyError: if (key != 'Ref' or res not in self.stack.parameters): raise exception.InvalidTemplateReference( resource=res, key=path) else: if key == 'DependsOn' or target.strict_dependency: deps += (self, target) else: self._add_dependencies(deps, '%s.%s' % (path, key), value) elif isinstance(fragment, list): for index, item in enumerate(fragment): self._add_dependencies(deps, '%s[%d]' % (path, index), item) def add_dependencies(self, deps): self._add_dependencies(deps, self.name, self.json_snippet) deps += (self, None) def required_by(self): ''' Returns a list of names of resources which directly require this resource as a dependency. ''' return list( [r.name for r in self.stack.dependencies.required_by(self)]) def keystone(self): return self.stack.clients.keystone() def nova(self, service_type='compute'): return self.stack.clients.nova(service_type) def swift(self): return self.stack.clients.swift() def neutron(self): return self.stack.clients.neutron() def cinder(self): return self.stack.clients.cinder() def trove(self): return self.stack.clients.trove() def ceilometer(self): return self.stack.clients.ceilometer() def heat(self): return self.stack.clients.heat() def _do_action(self, action, pre_func=None, resource_data=None): ''' Perform a transition to a new state via a specified action action should be e.g self.CREATE, self.UPDATE etc, we set status based on this, the transition is handled by calling the corresponding handle_* and check_*_complete functions Note pre_func is an optional function reference which will be called before the handle_ function If the resource does not declare a check_$action_complete function, we declare COMPLETE status as soon as the handle_$action call has finished, and if no handle_$action function is declared, then we do nothing, useful e.g if the resource requires no action for a given state transition ''' assert action in self.ACTIONS, 'Invalid action %s' % action try: self.state_set(action, self.IN_PROGRESS) action_l = action.lower() handle = getattr(self, 'handle_%s' % action_l, None) check = getattr(self, 'check_%s_complete' % action_l, None) if callable(pre_func): pre_func() handle_data = None if callable(handle): handle_data = (handle(resource_data) if resource_data else handle()) yield if callable(check): while not check(handle_data): yield except Exception as ex: logger.exception('%s : %s' % (action, str(self))) failure = exception.ResourceFailure(ex, self, action) self.state_set(action, self.FAILED, str(failure)) raise failure except: with excutils.save_and_reraise_exception(): try: self.state_set(action, self.FAILED, '%s aborted' % action) except Exception: logger.exception(_('Error marking resource as failed')) else: self.state_set(action, self.COMPLETE) def preview(self): ''' Default implementation of Resource.preview. This method should be overriden by child classes for specific behavior. ''' return self def create(self): ''' Create the resource. Subclasses should provide a handle_create() method to customise creation. ''' action = self.CREATE if (self.action, self.status) != (self.INIT, self.COMPLETE): exc = exception.Error(_('State %s invalid for create') % str(self.state)) raise exception.ResourceFailure(exc, self, action) logger.info('creating %s' % str(self)) # Re-resolve the template, since if the resource Ref's # the StackId pseudo parameter, it will change after # the parser.Stack is stored (which is after the resources # are __init__'d, but before they are create()'d) self.reparse() return self._do_action(action, self.properties.validate) def set_deletion_policy(self, policy): self.t['DeletionPolicy'] = policy def get_abandon_data(self): return { 'name': self.name, 'resource_id': self.resource_id, 'type': self.type(), 'action': self.action, 'status': self.status, 'metadata': self.metadata, 'resource_data': db_api.resource_data_get_all(self) } def adopt(self, resource_data): ''' Adopt the existing resource. Resource subclasses can provide a handle_adopt() method to customise adopt. ''' return self._do_action(self.ADOPT, resource_data=resource_data) def handle_adopt(self, resource_data=None): resource_id, data, metadata = self._get_resource_info(resource_data) if not resource_id: exc = Exception(_('Resource ID was not provided.')) failure = exception.ResourceFailure(exc, self) raise failure # set resource id self.resource_id_set(resource_id) # save the resource data if data and isinstance(data, dict): for key, value in data.iteritems(): db_api.resource_data_set(self, key, value) # save the resource metadata self.metadata = metadata def _get_resource_info(self, resource_data): if not resource_data: return None, None, None return (resource_data.get('resource_id'), resource_data.get('resource_data'), resource_data.get('metadata')) def update(self, after, before=None, prev_resource=None): ''' update the resource. Subclasses should provide a handle_update() method to customise update, the base-class handle_update will fail by default. ''' action = self.UPDATE (cur_class_def, cur_ver) = self.implementation_signature() prev_ver = cur_ver if prev_resource is not None: (prev_class_def, prev_ver) = prev_resource.implementation_signature() if prev_class_def != cur_class_def: raise UpdateReplace(self.name) if before is None: before = self.parsed_template() if prev_ver == cur_ver and before == after: return if (self.action, self.status) in ((self.CREATE, self.IN_PROGRESS), (self.UPDATE, self.IN_PROGRESS), (self.ADOPT, self.IN_PROGRESS)): exc = Exception(_('Resource update already requested')) raise exception.ResourceFailure(exc, self, action) logger.info('updating %s' % str(self)) try: self.updated_time = datetime.utcnow() self.state_set(action, self.IN_PROGRESS) properties = Properties(self.properties_schema, after.get('Properties', {}), self._resolve_runtime_data, self.name, self.context) properties.validate() tmpl_diff = self.update_template_diff(after, before) prop_diff = self.update_template_diff_properties(after, before) if callable(getattr(self, 'handle_update', None)): handle_data = self.handle_update(after, tmpl_diff, prop_diff) yield if callable(getattr(self, 'check_update_complete', None)): while not self.check_update_complete(handle_data): yield except UpdateReplace: with excutils.save_and_reraise_exception(): logger.debug(_("Resource %s update requires replacement") % self.name) except Exception as ex: logger.exception('update %s : %s' % (str(self), str(ex))) failure = exception.ResourceFailure(ex, self, action) self.state_set(action, self.FAILED, str(failure)) raise failure else: self.json_snippet = copy.deepcopy(after) self.reparse() self.state_set(action, self.COMPLETE) def suspend(self): ''' Suspend the resource. Subclasses should provide a handle_suspend() method to implement suspend ''' action = self.SUSPEND # Don't try to suspend the resource unless it's in a stable state if (self.action == self.DELETE or self.status != self.COMPLETE): exc = exception.Error(_('State %s invalid for suspend') % str(self.state)) raise exception.ResourceFailure(exc, self, action) logger.info(_('suspending %s') % str(self)) return self._do_action(action) def resume(self): ''' Resume the resource. Subclasses should provide a handle_resume() method to implement resume ''' action = self.RESUME # Can't resume a resource unless it's SUSPEND_COMPLETE if self.state != (self.SUSPEND, self.COMPLETE): exc = exception.Error(_('State %s invalid for resume') % str(self.state)) raise exception.ResourceFailure(exc, self, action) logger.info(_('resuming %s') % str(self)) return self._do_action(action) def physical_resource_name(self): if self.id is None: return None name = '%s-%s-%s' % (self.stack.name, self.name, short_id.get_id(self.id)) if self.physical_resource_name_limit: name = self.reduce_physical_resource_name( name, self.physical_resource_name_limit) return name @staticmethod def reduce_physical_resource_name(name, limit): ''' Reduce length of physical resource name to a limit. The reduced name will consist of the following: * the first 2 characters of the name * a hyphen * the end of the name, truncated on the left to bring the name length within the limit :param name: The name to reduce the length of :param limit: The max length limit :returns: A name whose length is less than or equal to the limit ''' if len(name) <= limit: return name if limit < 4: raise ValueError(_('limit cannot be less than 4')) postfix_length = limit - 3 return name[0:2] + '-' + name[-postfix_length:] def validate(self): logger.info(_('Validating %s') % str(self)) self.validate_deletion_policy(self.t) return self.properties.validate() @classmethod def validate_deletion_policy(cls, template): deletion_policy = template.get('DeletionPolicy', DELETE) if deletion_policy not in DELETION_POLICY: msg = _('Invalid DeletionPolicy %s') % deletion_policy raise exception.StackValidationFailed(message=msg) elif deletion_policy == SNAPSHOT: if not callable(getattr(cls, 'handle_snapshot_delete', None)): msg = _('Snapshot DeletionPolicy not supported') raise exception.StackValidationFailed(message=msg) def delete(self): ''' Delete the resource. Subclasses should provide a handle_delete() method to customise deletion. ''' action = self.DELETE if (self.action, self.status) == (self.DELETE, self.COMPLETE): return # No need to delete if the resource has never been created if self.action == self.INIT: return initial_state = self.state logger.info(_('deleting %s') % str(self)) try: self.state_set(action, self.IN_PROGRESS) deletion_policy = self.t.get('DeletionPolicy', DELETE) handle_data = None if deletion_policy == DELETE: if callable(getattr(self, 'handle_delete', None)): handle_data = self.handle_delete() yield elif deletion_policy == SNAPSHOT: if callable(getattr(self, 'handle_snapshot_delete', None)): handle_data = self.handle_snapshot_delete(initial_state) yield if (deletion_policy != RETAIN and callable(getattr(self, 'check_delete_complete', None))): while not self.check_delete_complete(handle_data): yield except Exception as ex: logger.exception(_('Delete %s'), str(self)) failure = exception.ResourceFailure(ex, self, self.action) self.state_set(action, self.FAILED, str(failure)) raise failure except: with excutils.save_and_reraise_exception(): try: self.state_set(action, self.FAILED, 'Deletion aborted') except Exception: logger.exception(_('Error marking resource deletion ' 'failed')) else: self.state_set(action, self.COMPLETE) @scheduler.wrappertask def destroy(self): ''' Delete the resource and remove it from the database. ''' yield self.delete() if self.id is None: return try: db_api.resource_get(self.context, self.id).delete() except exception.NotFound: # Don't fail on delete if the db entry has # not been created yet. pass self.id = None def resource_id_set(self, inst): self.resource_id = inst if self.id is not None: try: rs = db_api.resource_get(self.context, self.id) rs.update_and_save({'nova_instance': self.resource_id}) except Exception as ex: logger.warn(_('db error %s') % str(ex)) def _store(self): '''Create the resource in the database.''' metadata = self.metadata try: rs = {'action': self.action, 'status': self.status, 'status_reason': self.status_reason, 'stack_id': self.stack.id, 'nova_instance': self.resource_id, 'name': self.name, 'rsrc_metadata': metadata, 'stack_name': self.stack.name} new_rs = db_api.resource_create(self.context, rs) self.id = new_rs.id self.created_time = new_rs.created_at except Exception as ex: logger.error(_('DB error %s') % str(ex)) def _add_event(self, action, status, reason): '''Add a state change event to the database.''' ev = event.Event(self.context, self.stack, action, status, reason, self.resource_id, self.properties, self.name, self.type()) try: ev.store() except Exception as ex: logger.error(_('DB error %s') % str(ex)) def _store_or_update(self, action, status, reason): self.action = action self.status = status self.status_reason = reason if self.id is not None: try: rs = db_api.resource_get(self.context, self.id) rs.update_and_save({'action': self.action, 'status': self.status, 'status_reason': reason, 'stack_id': self.stack.id, 'updated_at': self.updated_time, 'nova_instance': self.resource_id}) except Exception as ex: logger.error(_('DB error %s') % str(ex)) # store resource in DB on transition to CREATE_IN_PROGRESS # all other transistions (other than to DELETE_COMPLETE) # should be handled by the update_and_save above.. elif (action, status) in [(self.CREATE, self.IN_PROGRESS), (self.ADOPT, self.IN_PROGRESS)]: self._store() def _resolve_attribute(self, name): """ Default implementation; should be overridden by resources that expose attributes :param name: The attribute to resolve :returns: the resource attribute named key """ # By default, no attributes resolve pass def state_reset(self): """ Reset state to (INIT, COMPLETE) """ self.action = self.INIT self.status = self.COMPLETE def state_set(self, action, status, reason="state changed"): if action not in self.ACTIONS: raise ValueError(_("Invalid action %s") % action) if status not in self.STATUSES: raise ValueError(_("Invalid status %s") % status) old_state = (self.action, self.status) new_state = (action, status) self._store_or_update(action, status, reason) if new_state != old_state: self._add_event(action, status, reason) @property def state(self): '''Returns state, tuple of action, status.''' return (self.action, self.status) def FnGetRefId(self): ''' For the intrinsic function Ref. :results: the id or name of the resource. ''' if self.resource_id is not None: return unicode(self.resource_id) else: return unicode(self.name) def FnGetAtt(self, key): ''' For the intrinsic function Fn::GetAtt. :param key: the attribute key. :returns: the attribute value. ''' try: return self.attributes[key] except KeyError: raise exception.InvalidTemplateAttribute(resource=self.name, key=key) def FnBase64(self, data): ''' For the instrinsic function Fn::Base64. :param data: the input data. :returns: the Base64 representation of the input data. ''' return base64.b64encode(data) def signal(self, details=None): ''' signal the resource. Subclasses should provide a handle_signal() method to implement the signal, the base-class raise an exception if no handler is implemented. ''' def get_string_details(): if details is None: return 'No signal details provided' if isinstance(details, basestring): return details if isinstance(details, dict): if all(k in details for k in ('previous', 'current', 'reason')): # this is from Ceilometer. auto = '%(previous)s to %(current)s (%(reason)s)' % details return 'alarm state changed from %s' % auto elif 'state' in details: # this is from watchrule return 'alarm state changed to %(state)s' % details elif 'deploy_status_code' in details: # this is for SoftwareDeployment if details['deploy_status_code'] == 0: return 'deployment succeeded' else: return ('deployment failed ' '(%(deploy_status_code)s)' % details) return 'Unknown' try: if not callable(getattr(self, 'handle_signal', None)): msg = (_('Resource %s is not able to receive a signal') % str(self)) raise Exception(msg) self._add_event('signal', self.status, get_string_details()) self.handle_signal(details) except Exception as ex: logger.exception(_('signal %(name)s : %(msg)s') % {'name': str(self), 'msg': str(ex)}) failure = exception.ResourceFailure(ex, self) raise failure def handle_update(self, json_snippet=None, tmpl_diff=None, prop_diff=None): raise UpdateReplace(self.name) def metadata_update(self, new_metadata=None): ''' No-op for resources which don't explicitly override this method ''' if new_metadata: logger.warning(_("Resource %s does not implement metadata update") % self.name) @classmethod def resource_to_template(cls, resource_type): ''' :param resource_type: The resource type to be displayed in the template :returns: A template where the resource's properties_schema is mapped as parameters, and the resource's attributes_schema is mapped as outputs ''' (parameters, properties) = (Properties. schema_to_parameters_and_properties( cls.properties_schema)) resource_name = cls.__name__ return { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': parameters, 'Resources': { resource_name: { 'Type': resource_type, 'Properties': properties } }, 'Outputs': Attributes.as_outputs(resource_name, cls) } heat-2014.1.5/heat/engine/clients.py0000664000567000056700000002661012540642614020237 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. from oslo.config import cfg from heat.openstack.common import importutils from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) from heat.common import heat_keystoneclient as hkc from heatclient import client as heatclient from novaclient import client as novaclient from novaclient import shell as novashell try: from swiftclient import client as swiftclient except ImportError: swiftclient = None logger.info(_('swiftclient not available')) try: from neutronclient.v2_0 import client as neutronclient except ImportError: neutronclient = None logger.info(_('neutronclient not available')) try: from cinderclient import client as cinderclient except ImportError: cinderclient = None logger.info(_('cinderclient not available')) try: from troveclient import client as troveclient except ImportError: troveclient = None logger.info(_('troveclient not available')) try: from ceilometerclient import client as ceilometerclient except ImportError: ceilometerclient = None logger.info(_('ceilometerclient not available')) _default_backend = "heat.engine.clients.OpenStackClients" cloud_opts = [ cfg.StrOpt('cloud_backend', default=_default_backend, help="Fully qualified class name to use as a client backend.") ] cfg.CONF.register_opts(cloud_opts) class OpenStackClients(object): ''' Convenience class to create and cache client instances. ''' def __init__(self, context): self.context = context self._nova = {} self._keystone = None self._swift = None self._neutron = None self._cinder = None self._trove = None self._ceilometer = None self._heat = None @property def auth_token(self): # if there is no auth token in the context # attempt to get one using the context username and password return self.context.auth_token or self.keystone().auth_token def keystone(self): if self._keystone: return self._keystone self._keystone = hkc.KeystoneClient(self.context) return self._keystone def url_for(self, **kwargs): return self.keystone().url_for(**kwargs) def nova(self, service_type='compute'): if service_type in self._nova: return self._nova[service_type] con = self.context if self.auth_token is None: logger.error(_("Nova connection failed, no auth_token!")) return None computeshell = novashell.OpenStackComputeShell() extensions = computeshell._discover_extensions("1.1") endpoint_type = self._get_client_option('nova', 'endpoint_type') args = { 'project_id': con.tenant, 'auth_url': con.auth_url, 'service_type': service_type, 'username': None, 'api_key': None, 'extensions': extensions, 'endpoint_type': endpoint_type, 'cacert': self._get_client_option('nova', 'ca_file'), 'insecure': self._get_client_option('nova', 'insecure') } client = novaclient.Client(1.1, **args) management_url = self.url_for(service_type=service_type, endpoint_type=endpoint_type) client.client.auth_token = self.auth_token client.client.management_url = management_url self._nova[service_type] = client return client def swift(self): if swiftclient is None: return None if self._swift: return self._swift con = self.context if self.auth_token is None: logger.error(_("Swift connection failed, no auth_token!")) return None endpoint_type = self._get_client_option('swift', 'endpoint_type') args = { 'auth_version': '2.0', 'tenant_name': con.tenant, 'user': con.username, 'key': None, 'authurl': None, 'preauthtoken': self.auth_token, 'preauthurl': self.url_for(service_type='object-store', endpoint_type=endpoint_type), 'os_options': {'endpoint_type': endpoint_type}, 'cacert': self._get_client_option('swift', 'ca_file'), 'insecure': self._get_client_option('swift', 'insecure') } self._swift = swiftclient.Connection(**args) return self._swift def neutron(self): if neutronclient is None: return None if self._neutron: return self._neutron con = self.context if self.auth_token is None: logger.error(_("Neutron connection failed, no auth_token!")) return None endpoint_type = self._get_client_option('neutron', 'endpoint_type') args = { 'auth_url': con.auth_url, 'service_type': 'network', 'token': self.auth_token, 'endpoint_url': self.url_for(service_type='network', endpoint_type=endpoint_type), 'endpoint_type': endpoint_type, 'ca_cert': self._get_client_option('neutron', 'ca_file'), 'insecure': self._get_client_option('neutron', 'insecure') } self._neutron = neutronclient.Client(**args) return self._neutron def cinder(self): if cinderclient is None: return self.nova('volume') if self._cinder: return self._cinder con = self.context if self.auth_token is None: logger.error(_("Cinder connection failed, no auth_token!")) return None endpoint_type = self._get_client_option('cinder', 'endpoint_type') args = { 'service_type': 'volume', 'auth_url': con.auth_url, 'project_id': con.tenant, 'username': None, 'api_key': None, 'endpoint_type': endpoint_type, 'cacert': self._get_client_option('cinder', 'ca_file'), 'insecure': self._get_client_option('cinder', 'insecure') } self._cinder = cinderclient.Client('1', **args) management_url = self.url_for(service_type='volume', endpoint_type=endpoint_type) self._cinder.client.auth_token = self.auth_token self._cinder.client.management_url = management_url return self._cinder def trove(self, service_type="database"): if troveclient is None: return None if self._trove: return self._trove con = self.context if self.auth_token is None: logger.error(_("Trove connection failed, no auth_token!")) return None endpoint_type = self._get_client_option('trove', 'endpoint_type') args = { 'service_type': service_type, 'auth_url': con.auth_url, 'proxy_token': con.auth_token, 'username': None, 'password': None, 'cacert': self._get_client_option('trove', 'ca_file'), 'insecure': self._get_client_option('trove', 'insecure'), 'endpoint_type': endpoint_type } self._trove = troveclient.Client('1.0', **args) management_url = self.url_for(service_type=service_type, endpoint_type=endpoint_type) self._trove.client.auth_token = con.auth_token self._trove.client.management_url = management_url return self._trove def ceilometer(self): if ceilometerclient is None: return None if self._ceilometer: return self._ceilometer if self.auth_token is None: logger.error(_("Ceilometer connection failed, no auth_token!")) return None con = self.context endpoint_type = self._get_client_option('ceilometer', 'endpoint_type') endpoint = self.url_for(service_type='metering', endpoint_type=endpoint_type) args = { 'auth_url': con.auth_url, 'service_type': 'metering', 'project_id': con.tenant, 'token': lambda: self.auth_token, 'endpoint_type': endpoint_type, 'ca_file': self._get_client_option('ceilometer', 'ca_file'), 'cert_file': self._get_client_option('ceilometer', 'cert_file'), 'key_file': self._get_client_option('ceilometer', 'key_file'), 'insecure': self._get_client_option('ceilometer', 'insecure') } client = ceilometerclient.Client('2', endpoint, **args) self._ceilometer = client return self._ceilometer def _get_client_option(self, client, option): try: group_name = 'clients_' + client cfg.CONF.import_opt(option, 'heat.common.config', group=group_name) return getattr(getattr(cfg.CONF, group_name), option) except (cfg.NoSuchGroupError, cfg.NoSuchOptError): cfg.CONF.import_opt(option, 'heat.common.config', group='clients') return getattr(cfg.CONF.clients, option) def _get_heat_url(self): heat_url = self._get_client_option('heat', 'url') if heat_url: tenant_id = self.context.tenant_id heat_url = heat_url % {'tenant_id': tenant_id} return heat_url def heat(self): if self._heat: return self._heat con = self.context if self.auth_token is None: logger.error(_("Heat connection failed, no auth_token!")) return None endpoint_type = self._get_client_option('heat', 'endpoint_type') args = { 'auth_url': con.auth_url, 'token': self.auth_token, 'username': None, 'password': None, 'ca_file': self._get_client_option('heat', 'ca_file'), 'cert_file': self._get_client_option('heat', 'cert_file'), 'key_file': self._get_client_option('heat', 'key_file'), 'insecure': self._get_client_option('heat', 'insecure') } endpoint = self._get_heat_url() if not endpoint: endpoint = self.url_for(service_type='orchestration', endpoint_type=endpoint_type) self._heat = heatclient.Client('1', endpoint, **args) return self._heat class ClientBackend(object): '''Delay choosing the backend client module until the client's class needs to be initialized. ''' def __new__(cls, context): if cfg.CONF.cloud_backend == _default_backend: return OpenStackClients(context) else: return importutils.import_object( cfg.CONF.cloud_backend, context ) Clients = ClientBackend heat-2014.1.5/heat/engine/cfn/0000775000567000056700000000000012540643116016763 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/cfn/template.py0000664000567000056700000000425312540642614021156 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # # 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. from heat.engine import parameters from heat.engine import template class CfnTemplate(template.Template): '''A stack template.''' SECTIONS = (VERSION, ALTERNATE_VERSION, DESCRIPTION, MAPPINGS, PARAMETERS, RESOURCES, OUTPUTS) = \ ('AWSTemplateFormatVersion', 'HeatTemplateFormatVersion', 'Description', 'Mappings', 'Parameters', 'Resources', 'Outputs' ) SECTIONS_NO_DIRECT_ACCESS = set([PARAMETERS, VERSION, ALTERNATE_VERSION]) def __getitem__(self, section): '''Get the relevant section in the template.''' if section not in self.SECTIONS: raise KeyError(_('"%s" is not a valid template section') % section) if section in self.SECTIONS_NO_DIRECT_ACCESS: raise KeyError( _('Section %s can not be accessed directly.') % section) if section == self.DESCRIPTION: default = 'No description' else: default = {} return self.t.get(section, default) def param_schemata(self): params = self.t.get(self.PARAMETERS, {}).iteritems() return dict((name, parameters.Schema.from_dict(schema)) for name, schema in params) def parameters(self, stack_identifier, user_params): return parameters.Parameters(stack_identifier, self, user_params=user_params) def template_mapping(): return { ('HeatTemplateFormatVersion', '2012-12-12'): CfnTemplate, ('AWSTemplateFormatVersion', '2010-09-09'): CfnTemplate, } heat-2014.1.5/heat/engine/cfn/__init__.py0000664000567000056700000000000012540642611021061 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/cfn/functions.py0000664000567000056700000004212412540642614021352 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. import collections import json from heat.api.aws import utils as aws_utils from heat.common import exception from heat.engine import function class FindInMap(function.Function): ''' A function for resolving keys in the template mappings. Takes the form:: { "Fn::FindInMap" : [ "mapping", "key", "value" ] } ''' def __init__(self, stack, fn_name, args): super(FindInMap, self).__init__(stack, fn_name, args) try: self._mapname, self._mapkey, self._mapvalue = self.args except ValueError as ex: raise KeyError(str(ex)) def result(self): mapping = self.stack.t.maps[function.resolve(self._mapname)] key = function.resolve(self._mapkey) value = function.resolve(self._mapvalue) return mapping[key][value] class GetAZs(function.Function): ''' A function for retrieving the availability zones. Takes the form:: { "Fn::GetAZs" : "" } ''' def result(self): # TODO(therve): Implement region scoping #region = function.resolve(self.args) if self.stack is None: return ['nova'] else: return self.stack.get_availability_zones() class ParamRef(function.Function): ''' A function for resolving parameter references. Takes the form:: { "Ref" : "" } ''' def __init__(self, stack, fn_name, args): super(ParamRef, self).__init__(stack, fn_name, args) self.parameters = self.stack.parameters def result(self): param_name = function.resolve(self.args) try: return self.parameters[param_name] except (KeyError, ValueError): raise exception.UserParameterMissing(key=param_name) class ResourceRef(function.Function): ''' A function for resolving resource references. Takes the form:: { "Ref" : "" } ''' def _resource(self): resource_name = function.resolve(self.args) return self.stack[resource_name] def result(self): return self._resource().FnGetRefId() def Ref(stack, fn_name, args): ''' A function for resolving parameters or resource references. Takes the form:: { "Ref" : "" } or:: { "Ref" : "" } ''' if args in stack: RefClass = ResourceRef else: RefClass = ParamRef return RefClass(stack, fn_name, args) class GetAtt(function.Function): ''' A function for resolving resource attributes. Takes the form:: { "Fn::GetAtt" : [ "", "", [ "", "", ... ] ] } Takes the form (for a map lookup):: { "Fn::Select" : [ "", { "": "", ... } ] } If the selected index is not found, this function resolves to an empty string. ''' def __init__(self, stack, fn_name, args): super(Select, self).__init__(stack, fn_name, args) try: self._lookup, self._strings = self.args except ValueError: raise ValueError(_('Arguments to "%s" must be of the form ' '[index, collection]') % self.fn_name) def result(self): index = function.resolve(self._lookup) try: index = int(index) except (ValueError, TypeError): pass strings = function.resolve(self._strings) if strings == '': # an empty string is a common response from other # functions when result is not currently available. # Handle by returning an empty string return '' if isinstance(strings, basestring): # might be serialized json. try: strings = json.loads(strings) except ValueError as json_ex: fmt_data = {'fn_name': self.fn_name, 'err': json_ex} raise ValueError(_('"%(fn_name)s": %(err)s') % fmt_data) if isinstance(strings, collections.Mapping): if not isinstance(index, basestring): raise TypeError(_('Index to "%s" must be a string') % self.fn_name) return strings.get(index, '') if (isinstance(strings, collections.Sequence) and not isinstance(strings, basestring)): if not isinstance(index, (int, long)): raise TypeError(_('Index to "%s" must be an integer') % self.fn_name) try: return strings[index] except IndexError: return '' if strings is None: return '' raise TypeError(_('Arguments to %s not fully resolved') % self.fn_name) class Join(function.Function): ''' A function for joining strings. Takes the form:: { "Fn::Join" : [ "", [ "", "", ... ] } And resolves to:: "..." ''' def __init__(self, stack, fn_name, args): super(Join, self).__init__(stack, fn_name, args) example = '"%s" : [ " ", [ "str1", "str2"]]' % self.fn_name fmt_data = {'fn_name': self.fn_name, 'example': example} if isinstance(self.args, (basestring, collections.Mapping)): raise TypeError(_('Incorrect arguments to "%(fn_name)s" ' 'should be: %(example)s') % fmt_data) try: self._delim, self._strings = self.args except ValueError: raise ValueError(_('Incorrect arguments to "%(fn_name)s" ' 'should be: %(example)s') % fmt_data) def result(self): strings = function.resolve(self._strings) if strings is None: strings = [] if (isinstance(strings, basestring) or not isinstance(strings, collections.Sequence)): raise TypeError(_('"%s" must operate on a list') % self.fn_name) delim = function.resolve(self._delim) if not isinstance(delim, basestring): raise TypeError(_('"%s" delimiter must be a string') % self.fn_name) def ensure_string(s): if s is None: return '' if not isinstance(s, basestring): raise TypeError(_('Items to join must be strings')) return s return delim.join(ensure_string(s) for s in strings) class Split(function.Function): ''' A function for splitting strings. Takes the form:: { "Fn::Split" : [ "", "..." ] } And resolves to:: [ "", "", ... ] ''' def __init__(self, stack, fn_name, args): super(Split, self).__init__(stack, fn_name, args) example = '"%s" : [ ",", "str1,str2"]]' % self.fn_name fmt_data = {'fn_name': self.fn_name, 'example': example} if isinstance(self.args, (basestring, collections.Mapping)): raise TypeError(_('Incorrect arguments to "%(fn_name)s" ' 'should be: %(example)s') % fmt_data) try: self._delim, self._strings = self.args except ValueError: raise ValueError(_('Incorrect arguments to "%(fn_name)s" ' 'should be: %(example)s') % fmt_data) def result(self): strings = function.resolve(self._strings) if not isinstance(self._delim, basestring): raise TypeError(_("Delimiter for %s must be string") % self.fn_name) if not isinstance(strings, basestring): raise TypeError(_("String to split must be string; got %s") % type(strings)) return strings.split(self._delim) class Replace(function.Function): ''' A function for performing string subsitutions. Takes the form:: { "Fn::Replace" : [ { "": "", "": "", ... }, " " ] } And resolves to:: " " This is implemented using python str.replace on each key. The order in which replacements are performed is undefined. ''' def __init__(self, stack, fn_name, args): super(Replace, self).__init__(stack, fn_name, args) self._mapping, self._string = self._parse_args() if not isinstance(self._mapping, collections.Mapping): raise TypeError(_('"%s" parameters must be a mapping') % self.fn_name) def _parse_args(self): example = ('{"%s": ' '[ {"$var1": "foo", "%%var2%%": "bar"}, ' '"$var1 is %%var2%%"]}' % self.fn_name) fmt_data = {'fn_name': self.fn_name, 'example': example} if isinstance(self.args, (basestring, collections.Mapping)): raise TypeError(_('Incorrect arguments to "%(fn_name)s" ' 'should be: %(example)s') % fmt_data) try: mapping, string = self.args except ValueError: raise ValueError(_('Incorrect arguments to "%(fn_name)s" ' 'should be: %(example)s') % fmt_data) else: return mapping, string def result(self): template = function.resolve(self._string) mapping = function.resolve(self._mapping) if not isinstance(template, basestring): raise TypeError(_('"%s" template must be a string') % self.fn_name) if not isinstance(mapping, collections.Mapping): raise TypeError(_('"%s" params must be a map') % self.fn_name) def replace(string, change): placeholder, value = change if not isinstance(placeholder, basestring): raise TypeError(_('"%s" param placeholders must be strings') % self.fn_name) if value is None: value = '' if not isinstance(value, (basestring, int, long, float, bool)): raise TypeError(_('"%s" params must be strings or numbers') % self.fn_name) return string.replace(placeholder, unicode(value)) return reduce(replace, mapping.iteritems(), template) class Base64(function.Function): ''' A placeholder function for converting to base64. Takes the form:: { "Fn::Base64" : "" } This function actually performs no conversion. It is included for the benefit of templates that convert UserData to Base64. Heat accepts UserData in plain text. ''' def result(self): resolved = function.resolve(self.args) if not isinstance(resolved, basestring): raise TypeError(_('"%s" argument must be a string') % self.fn_name) return resolved class MemberListToMap(function.Function): ''' A function for converting lists containing enumerated keys and values to a mapping. Takes the form:: { 'Fn::MemberListToMap' : [ 'Name', 'Value', [ '.member.0.Name=', '.member.0.Value=', ... ] ] } And resolves to:: { "" : "", ... } The first two arguments are the names of the key and value. ''' def __init__(self, stack, fn_name, args): super(MemberListToMap, self).__init__(stack, fn_name, args) try: self._keyname, self._valuename, self._list = self.args except ValueError: correct = ''' {'Fn::MemberListToMap': ['Name', 'Value', ['.member.0.Name=key', '.member.0.Value=door']]} ''' raise TypeError(_('Wrong Arguments try: "%s"') % correct) if not isinstance(self._keyname, basestring): raise TypeError(_('%s Key Name must be a string') % self.fn_name) if not isinstance(self._valuename, basestring): raise TypeError(_('%s Value Name must be a string') % self.fn_name) def result(self): member_list = function.resolve(self._list) if not isinstance(member_list, collections.Iterable): raise TypeError(_('Member list must be a list')) def item(s): if not isinstance(s, basestring): raise TypeError(_("Member list items must be strings")) return s.split('=', 1) partials = dict(item(s) for s in member_list) return aws_utils.extract_param_pairs(partials, prefix='', keyname=self._keyname, valuename=self._valuename) class ResourceFacade(function.Function): ''' A function for obtaining data from the facade resource from within the corresponding provider template. Takes the form:: { "Fn::ResourceFacade": "" } where the valid attribute types are "Metadata", "DeletionPolicy" and "UpdatePolicy". ''' _RESOURCE_ATTRIBUTES = ( METADATA, DELETION_POLICY, UPDATE_POLICY, ) = ( 'Metadata', 'DeletionPolicy', 'UpdatePolicy' ) def __init__(self, stack, fn_name, args): super(ResourceFacade, self).__init__(stack, fn_name, args) if self.args not in self._RESOURCE_ATTRIBUTES: fmt_data = {'fn_name': self.fn_name, 'allowed': ', '.join(self._RESOURCE_ATTRIBUTES)} raise ValueError(_('Incorrect arguments to "%(fn_name)s" ' 'should be one of: %(allowed)s') % fmt_data) def result(self): attr = function.resolve(self.args) if attr == self.METADATA: return self.stack.parent_resource.metadata elif attr == self.UPDATE_POLICY: up = self.stack.parent_resource.t.get('UpdatePolicy', {}) return function.resolve(up) elif attr == self.DELETION_POLICY: dp = self.stack.parent_resource.t.get('DeletionPolicy', 'Delete') return function.resolve(dp) def function_mapping(version_key, version): if version_key == 'AWSTemplateFormatVersion': return { 'Fn::FindInMap': FindInMap, 'Fn::GetAZs': GetAZs, 'Ref': Ref, 'Fn::GetAtt': GetAtt, 'Fn::Select': Select, 'Fn::Join': Join, 'Fn::Base64': Base64, } elif version_key != 'HeatTemplateFormatVersion': return {} if version == '2012-12-12': return { 'Fn::FindInMap': FindInMap, 'Fn::GetAZs': GetAZs, 'Ref': Ref, 'Fn::GetAtt': GetAtt, 'Fn::Select': Select, 'Fn::Join': Join, 'Fn::Split': Split, 'Fn::Replace': Replace, 'Fn::Base64': Base64, 'Fn::MemberListToMap': MemberListToMap, 'Fn::ResourceFacade': ResourceFacade, } return {} heat-2014.1.5/heat/engine/environment.py0000664000567000056700000003725612540642614021152 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. import glob import itertools import os.path from oslo.config import cfg from heat.openstack.common import log from heat.openstack.common.gettextutils import _ from heat.common import environment_format from heat.common import exception LOG = log.getLogger(__name__) class ResourceInfo(object): """Base mapping of resource type to implementation.""" def __new__(cls, registry, path, value, **kwargs): '''Create a new ResourceInfo of the appropriate class.''' if cls != ResourceInfo: # Call is already for a subclass, so pass it through return super(ResourceInfo, cls).__new__(cls) name = path[-1] if name.endswith(('.yaml', '.template')): # a template url for the resource "Type" return TemplateResourceInfo(registry, path, value) elif not isinstance(value, basestring): return ClassResourceInfo(registry, path, value) elif value.endswith(('.yaml', '.template')): # a registered template return TemplateResourceInfo(registry, path, value) elif name.endswith('*'): return GlobResourceInfo(registry, path, value) else: return MapResourceInfo(registry, path, value) def __init__(self, registry, path, value): self.registry = registry self.path = path self.name = path[-1] self.value = value self.user_resource = True def __eq__(self, other): if other is None: return False return (self.path == other.path and self.value == other.value and self.user_resource == other.user_resource) def __ne__(self, other): return not self.__eq__(other) def __lt__(self, other): if self.user_resource != other.user_resource: # user resource must be sorted above system ones. return self.user_resource > other.user_resource if len(self.path) != len(other.path): # more specific (longer) path must be sorted above system ones. return len(self.path) > len(other.path) return self.path < other.path def __gt__(self, other): return other.__lt__(self) def get_resource_info(self, resource_type=None, resource_name=None): return self def matches(self, resource_type): return False def __str__(self): return '[%s](User:%s) %s -> %s' % (self.description, self.user_resource, self.name, str(self.value)) class ClassResourceInfo(ResourceInfo): """Store the mapping of resource name to python class implementation.""" description = 'Plugin' def get_class(self): return self.value class TemplateResourceInfo(ResourceInfo): """Store the info needed to start a TemplateResource. """ description = 'Template' def __init__(self, registry, path, value): super(TemplateResourceInfo, self).__init__(registry, path, value) if self.name.endswith(('.yaml', '.template')): self.template_name = self.name else: self.template_name = value self.value = self.template_name def get_class(self): from heat.engine.resources import template_resource return template_resource.generate_class(str(self.name), self.template_name) class MapResourceInfo(ResourceInfo): """Store the mapping of one resource type to another. like: OS::Networking::FloatingIp -> OS::Neutron::FloatingIp """ description = 'Mapping' def get_class(self): return None def get_resource_info(self, resource_type=None, resource_name=None): return self.registry.get_resource_info(self.value, resource_name) class GlobResourceInfo(MapResourceInfo): """Store the mapping (with wild cards) of one resource type to another. like: OS::Networking::* -> OS::Neutron::* """ description = 'Wildcard Mapping' def get_resource_info(self, resource_type=None, resource_name=None): orig_prefix = self.name[:-1] new_type = self.value[:-1] + resource_type[len(orig_prefix):] return self.registry.get_resource_info(new_type, resource_name) def matches(self, resource_type): return resource_type.startswith(self.name[:-1]) class ResourceRegistry(object): """By looking at the environment, find the resource implementation.""" def __init__(self, global_registry): self._registry = {'resources': {}} self.global_registry = global_registry def load(self, json_snippet): self._load_registry([], json_snippet) def register_class(self, resource_type, resource_class): ri = ResourceInfo(self, [resource_type], resource_class) self._register_info([resource_type], ri) def _load_registry(self, path, registry): for k, v in iter(registry.items()): if v is None: self._register_info(path + [k], None) elif isinstance(v, dict): self._load_registry(path + [k], v) else: self._register_info(path + [k], ResourceInfo(self, path + [k], v)) def _register_info(self, path, info): """place the new info in the correct location in the registry. path: a list of keys ['resources', 'my_server', 'OS::Nova::Server'] """ descriptive_path = '/'.join(path) name = path[-1] # create the structure if needed registry = self._registry for key in path[:-1]: if key not in registry: registry[key] = {} registry = registry[key] if info is None: if name.endswith('*'): # delete all matching entries. for res_name in registry.keys(): if isinstance(registry[res_name], ResourceInfo) and \ res_name.startswith(name[:-1]): LOG.warn(_('Removing %(item)s from %(path)s') % { 'item': res_name, 'path': descriptive_path}) del registry[res_name] else: # delete this entry. LOG.warn(_('Removing %(item)s from %(path)s') % { 'item': name, 'path': descriptive_path}) registry.pop(name, None) return if name in registry and isinstance(registry[name], ResourceInfo): if registry[name] == info: return details = { 'path': descriptive_path, 'was': str(registry[name].value), 'now': str(info.value)} LOG.warn(_('Changing %(path)s from %(was)s to %(now)s') % details) else: LOG.info(_('Registering %(path)s -> %(value)s') % { 'path': descriptive_path, 'value': str(info.value)}) info.user_resource = (self.global_registry is not None) registry[name] = info def iterable_by(self, resource_type, resource_name=None): is_templ_type = resource_type.endswith(('.yaml', '.template')) if self.global_registry is not None and is_templ_type: # we only support dynamic resource types in user environments # not the global environment. # resource with a Type == a template # we dynamically create an entry as it has not been registered. if resource_type not in self._registry: res = ResourceInfo(self, [resource_type], None) self._register_info([resource_type], res) yield self._registry[resource_type] # handle a specific resource mapping. if resource_name: impl = self._registry['resources'].get(resource_name) if impl and resource_type in impl: yield impl[resource_type] # handle: "OS::Nova::Server" -> "Rackspace::Cloud::Server" impl = self._registry.get(resource_type) if impl: yield impl # handle: "OS::*" -> "Dreamhost::*" def is_a_glob(resource_type): return resource_type.endswith('*') globs = itertools.ifilter(is_a_glob, self._registry.keys()) for pattern in globs: if self._registry[pattern].matches(resource_type): yield self._registry[pattern] def get_resource_info(self, resource_type, resource_name=None, registry_type=None, accept_fn=None): """Find possible matches to the resource type and name. chain the results from the global and user registry to find a match. """ # use cases # 1) get the impl. # - filter_by(res_type=X), sort_by(res_name=W, is_user=True) # 2) in TemplateResource we need to get both the # TemplateClass and the ResourceClass # - filter_by(res_type=X, impl_type=TemplateResourceInfo), # sort_by(res_name=W, is_user=True) # - filter_by(res_type=X, impl_type=ClassResourceInfo), # sort_by(res_name=W, is_user=True) # 3) get_types() from the api # - filter_by(is_user=False) # 4) as_dict() to write to the db # - filter_by(is_user=True) if self.global_registry is not None: giter = self.global_registry.iterable_by(resource_type, resource_name) else: giter = [] matches = itertools.chain(self.iterable_by(resource_type, resource_name), giter) for info in sorted(matches): match = info.get_resource_info(resource_type, resource_name) if ((registry_type is None or isinstance(match, registry_type)) and (accept_fn is None or accept_fn(info))): return match def get_class(self, resource_type, resource_name=None, accept_fn=None): if resource_type == "": msg = _('Resource "%s" has no type') % resource_name raise exception.StackValidationFailed(message=msg) elif resource_type is None: msg = _('Non-empty resource type is required ' 'for resource "%s"') % resource_name raise exception.StackValidationFailed(message=msg) elif not isinstance(resource_type, basestring): msg = _('Resource "%s" type is not a string') % resource_name raise exception.StackValidationFailed(message=msg) info = self.get_resource_info(resource_type, resource_name=resource_name, accept_fn=accept_fn) if info is None: msg = _("Unknown resource Type : %s") % resource_type raise exception.StackValidationFailed(message=msg) return info.get_class() def as_dict(self): """Return user resources in a dict format.""" def _as_dict(level): tmp = {} for k, v in iter(level.items()): if isinstance(v, dict): tmp[k] = _as_dict(v) elif v.user_resource: tmp[k] = v.value return tmp return _as_dict(self._registry) def get_types(self, support_status): '''Return a list of valid resource types.''' def is_resource(key): return isinstance(self._registry[key], (ClassResourceInfo, TemplateResourceInfo)) def status_matches(cls): return (support_status is None or cls.get_class().support_status.status == support_status.encode()) return [name for name, cls in self._registry.iteritems() if is_resource(name) and status_matches(cls)] SECTIONS = (PARAMETERS, RESOURCE_REGISTRY) = \ ('parameters', 'resource_registry') class Environment(object): def __init__(self, env=None, user_env=True): """Create an Environment from a dict of varying format. 1) old-school flat parameters 2) or newer {resource_registry: bla, parameters: foo} :param env: the json environment :param user_env: boolean, if false then we manage python resources too. """ if env is None: env = {} if user_env: from heat.engine import resources global_registry = resources.global_env().registry else: global_registry = None self.registry = ResourceRegistry(global_registry) self.registry.load(env.get(RESOURCE_REGISTRY, {})) if 'parameters' in env: self.params = env['parameters'] else: self.params = dict((k, v) for (k, v) in env.iteritems() if k != RESOURCE_REGISTRY) self.constraints = {} def load(self, env_snippet): self.registry.load(env_snippet.get(RESOURCE_REGISTRY, {})) self.params.update(env_snippet.get('parameters', {})) def user_env_as_dict(self): """Get the environment as a dict, ready for storing in the db.""" return {RESOURCE_REGISTRY: self.registry.as_dict(), PARAMETERS: self.params} def register_class(self, resource_type, resource_class): self.registry.register_class(resource_type, resource_class) def register_constraint(self, constraint_name, constraint): self.constraints[constraint_name] = constraint def get_class(self, resource_type, resource_name=None): return self.registry.get_class(resource_type, resource_name) def get_types(self, support_status=None): return self.registry.get_types(support_status) def get_resource_info(self, resource_type, resource_name=None, registry_type=None): return self.registry.get_resource_info(resource_type, resource_name, registry_type) def get_constraint(self, name): return self.constraints.get(name) def read_global_environment(env, env_dir=None): if env_dir is None: cfg.CONF.import_opt('environment_dir', 'heat.common.config') env_dir = cfg.CONF.environment_dir try: env_files = glob.glob(os.path.join(env_dir, '*')) except OSError as osex: LOG.error(_('Failed to read %s') % env_dir) LOG.exception(osex) return for file_path in env_files: try: with open(file_path) as env_fd: LOG.info(_('Loading %s') % file_path) env_body = environment_format.parse(env_fd.read()) environment_format.default_for_missing(env_body) env.load(env_body) except ValueError as vex: LOG.error(_('Failed to parse %(file_path)s') % { 'file_path': file_path}) LOG.exception(vex) except IOError as ioex: LOG.error(_('Failed to read %(file_path)s') % { 'file_path': file_path}) LOG.exception(ioex) heat-2014.1.5/heat/engine/template.py0000664000567000056700000001463712540642614020417 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. import abc import collections import functools from heat.db import api as db_api from heat.common import exception from heat.engine import plugin_manager __all__ = ['Template'] DEFAULT_VERSION = ('HeatTemplateFormatVersion', '2012-12-12') _template_classes = None class TemplatePluginManager(object): '''A Descriptor class for caching PluginManagers. Keeps a cache of PluginManagers with the search directories corresponding to the package containing the owner class. ''' def __init__(self): self.plugin_managers = {} @staticmethod def package_name(obj_class): '''Return the package containing the given class.''' module_name = obj_class.__module__ return module_name.rsplit('.', 1)[0] def __get__(self, obj, obj_class): '''Get a PluginManager for a class.''' pkg = self.package_name(obj_class) if pkg not in self.plugin_managers: self.plugin_managers[pkg] = plugin_manager.PluginManager(pkg) return self.plugin_managers[pkg] def get_version(template_data, available_versions): version_keys = set(key for key, version in available_versions) candidate_keys = set(k for k, v in template_data.iteritems() if isinstance(v, basestring)) keys_present = version_keys & candidate_keys if not keys_present: return DEFAULT_VERSION if len(keys_present) > 1: explanation = _('Ambiguous versions (%s)') % ', '.join(keys_present) raise exception.InvalidTemplateVersion(explanation=explanation) version_key = keys_present.pop() return version_key, template_data[version_key] def get_template_class(plugin_mgr, template_data): global _template_classes if _template_classes is None: tmpl_mapping = plugin_manager.PluginMapping('template') _template_classes = dict(tmpl_mapping.load_all(plugin_mgr)) available_versions = _template_classes.keys() version = get_version(template_data, available_versions) try: return _template_classes[version] except KeyError: msg_data = {'version': ': '.join(version), 'available': ', '.join(v for vk, v in available_versions)} explanation = _('Unknown version (%(version)s). ' 'Should be one of: %(available)s') % msg_data raise exception.InvalidTemplateVersion(explanation=explanation) class Template(collections.Mapping): '''A stack template.''' _plugins = TemplatePluginManager() _functionmaps = {} def __new__(cls, template, *args, **kwargs): '''Create a new Template of the appropriate class.''' if cls != Template: TemplateClass = cls else: TemplateClass = get_template_class(cls._plugins, template) return super(Template, cls).__new__(TemplateClass) def __init__(self, template, template_id=None, files=None): ''' Initialise the template with a JSON object and a set of Parameters ''' self.id = template_id self.t = template self.files = files or {} self.maps = self[self.MAPPINGS] self.version = get_version(self.t, _template_classes.keys()) @classmethod def load(cls, context, template_id): '''Retrieve a Template with the given ID from the database.''' t = db_api.raw_template_get(context, template_id) return cls(t.template, template_id=template_id, files=t.files) def store(self, context=None): '''Store the Template in the database and return its ID.''' if self.id is None: rt = { 'template': self.t, 'files': self.files } new_rt = db_api.raw_template_create(context, rt) self.id = new_rt.id return self.id def __iter__(self): '''Return an iterator over the section names.''' return (s for s in self.SECTIONS if s not in self.SECTIONS_NO_DIRECT_ACCESS) def __len__(self): '''Return the number of sections.''' return len(self.SECTIONS) - len(self.SECTIONS_NO_DIRECT_ACCESS) @abc.abstractmethod def param_schemata(self): '''Return a dict of parameters.Schema objects for the parameters.''' pass @abc.abstractmethod def parameters(self, stack_identifier, user_params): '''Return a parameters.Parameters object for the stack.''' pass def functions(self): '''Return a dict of template functions keyed by name.''' if self.version not in self._functionmaps: mappings = plugin_manager.PluginMapping('function', *self.version) funcs = dict(mappings.load_all(self._plugins)) self._functionmaps[self.version] = funcs return self._functionmaps[self.version] def parse(self, stack, snippet): return parse(self.functions(), stack, snippet) def validate(self): '''Validate the template. Only validates the top-level sections of the template. Syntax inside sections is not checked here but in code parts that are responsible for working with the respective sections. ''' for k in self.t.keys(): if k not in self.SECTIONS: raise exception.InvalidTemplateSection(section=k) def parse(functions, stack, snippet): recurse = functools.partial(parse, functions, stack) if isinstance(snippet, collections.Mapping): if len(snippet) == 1: fn_name, args = next(snippet.iteritems()) Func = functions.get(fn_name) if Func is not None: return Func(stack, fn_name, recurse(args)) return dict((k, recurse(v)) for k, v in snippet.iteritems()) elif (not isinstance(snippet, basestring) and isinstance(snippet, collections.Iterable)): return [recurse(v) for v in snippet] else: return snippet heat-2014.1.5/heat/engine/timestamp.py0000664000567000056700000000306712540642614020602 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. from heat.common import exception class Timestamp(object): ''' A descriptor for writing a timestamp to the database. ''' def __init__(self, db_fetch, attribute): ''' Initialise with a function to fetch the database representation of an object (given a context and ID) and the name of the attribute to retrieve. ''' self.db_fetch = db_fetch self.attribute = attribute def __get__(self, obj, obj_class): ''' Get timestamp for the given object and class. ''' if obj is None or obj.id is None: return None o = self.db_fetch(obj.context, obj.id) return getattr(o, self.attribute) def __set__(self, obj, timestamp): '''Update the timestamp for the given object.''' if obj.id is None: raise exception.ResourceNotAvailable(resource_name=obj.name) o = self.db_fetch(obj.context, obj.id) o.update_and_save({self.attribute: timestamp}) heat-2014.1.5/heat/engine/constraints.py0000664000567000056700000004000712540642614021141 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. import collections import numbers import re from heat.engine import resources class InvalidSchemaError(Exception): pass class Schema(collections.Mapping): """ Schema base class for validating properties or parameters. Schema objects are serialisable to dictionaries following a superset of the HOT input Parameter schema using dict(). Serialises to JSON in the form:: { 'type': 'list', 'required': False 'constraints': [ { 'length': {'min': 1}, 'description': 'List must not be empty' } ], 'schema': { '*': { 'type': 'string' } }, 'description': 'An example list property.' } """ KEYS = ( TYPE, DESCRIPTION, DEFAULT, SCHEMA, REQUIRED, CONSTRAINTS, ) = ( 'type', 'description', 'default', 'schema', 'required', 'constraints', ) # Keywords for data types; each Schema subclass can define its respective # type name used in templates TYPE_KEYS = ( INTEGER_TYPE, STRING_TYPE, NUMBER_TYPE, BOOLEAN_TYPE, MAP_TYPE, LIST_TYPE, ) = ( 'INTEGER', 'STRING', 'NUMBER', 'BOOLEAN', 'MAP', 'LIST', ) # Default type names for data types used in templates; can be overridden by # subclasses TYPES = ( INTEGER, STRING, NUMBER, BOOLEAN, MAP, LIST, ) = ( 'Integer', 'String', 'Number', 'Boolean', 'Map', 'List', ) def __init__(self, data_type, description=None, default=None, schema=None, required=False, constraints=[], label=None): self._len = None self.label = label self.type = data_type if self.type not in self.TYPES: raise InvalidSchemaError(_('Invalid type (%s)') % self.type) self.description = description self.required = required if isinstance(schema, type(self)): if self.type != self.LIST: msg = _('Single schema valid only for ' '%(ltype)s, not %(utype)s') % dict(ltype=self.LIST, utype=self.type) raise InvalidSchemaError(msg) self.schema = AnyIndexDict(schema) else: self.schema = schema if self.schema is not None and self.type not in (self.LIST, self.MAP): msg = _('Schema valid only for %(ltype)s or ' '%(mtype)s, not %(utype)s') % dict(ltype=self.LIST, mtype=self.MAP, utype=self.type) raise InvalidSchemaError(msg) self.constraints = constraints self.default = default def validate(self, context=None): ''' Validates the schema. This method checks if the schema itself is valid, and if the default value - if present - complies to the schema's constraints. ''' for c in self.constraints: if not self._is_valid_constraint(c): err_msg = _('%(name)s constraint ' 'invalid for %(utype)s') % dict( name=type(c).__name__, utype=self.type) raise InvalidSchemaError(err_msg) self._validate_default(context) # validated nested schema(ta) if self.schema: if isinstance(self.schema, AnyIndexDict): self.schema.value.validate(context) else: for nested_schema in self.schema.values(): nested_schema.validate(context) def _validate_default(self, context): if self.default is not None: try: self.validate_constraints(self.default, context) except (ValueError, TypeError) as exc: raise InvalidSchemaError(_('Invalid default ' '%(default)s (%(exc)s)') % dict(default=self.default, exc=exc)) def set_default(self, default=None): """Set the default value for this Schema object.""" self.default = default def _is_valid_constraint(self, constraint): valid_types = getattr(constraint, 'valid_types', []) return any(self.type == getattr(self, t, None) for t in valid_types) @staticmethod def str_to_num(value): """Convert a string representation of a number into a numeric type.""" if isinstance(value, numbers.Number): return value try: return int(value) except ValueError: return float(value) def validate_constraints(self, value, context=None): for constraint in self.constraints: constraint.validate(value, context) def __getitem__(self, key): if key == self.TYPE: return self.type.lower() elif key == self.DESCRIPTION: if self.description is not None: return self.description elif key == self.DEFAULT: if self.default is not None: return self.default elif key == self.SCHEMA: if self.schema is not None: return dict((n, dict(s)) for n, s in self.schema.items()) elif key == self.REQUIRED: return self.required elif key == self.CONSTRAINTS: if self.constraints: return [dict(c) for c in self.constraints] raise KeyError(key) def __iter__(self): for k in self.KEYS: try: self[k] except KeyError: pass else: yield k def __len__(self): if self._len is None: self._len = len(list(iter(self))) return self._len class AnyIndexDict(collections.Mapping): """ A Mapping that returns the same value for any integer index. Used for storing the schema for a list. When converted to a dictionary, it contains a single item with the key '*'. """ ANYTHING = '*' def __init__(self, value): self.value = value def __getitem__(self, key): if key != self.ANYTHING and not isinstance(key, (int, long)): raise KeyError(_('Invalid key %s') % str(key)) return self.value def __iter__(self): yield self.ANYTHING def __len__(self): return 1 class Constraint(collections.Mapping): """ Parent class for constraints on allowable values for a Property. Constraints are serialisable to dictionaries following the HOT input Parameter constraints schema using dict(). """ (DESCRIPTION,) = ('description',) def __init__(self, description=None): self.description = description def __str__(self): def desc(): if self.description: yield self.description yield self._str() return '\n'.join(desc()) def validate(self, value, context=None): if not self._is_valid(value, context): if self.description: err_msg = self.description else: err_msg = self._err_msg(value) raise ValueError(err_msg) @classmethod def _name(cls): return '_'.join(w.lower() for w in re.findall('[A-Z]?[a-z]+', cls.__name__)) def __getitem__(self, key): if key == self.DESCRIPTION: if self.description is None: raise KeyError(key) return self.description if key == self._name(): return self._constraint() raise KeyError(key) def __iter__(self): if self.description is not None: yield self.DESCRIPTION yield self._name() def __len__(self): return 2 if self.description is not None else 1 class Range(Constraint): """ Constrain values within a range. Serialises to JSON as:: { 'range': {'min': , 'max': }, 'description': } """ (MIN, MAX) = ('min', 'max') valid_types = (Schema.INTEGER_TYPE, Schema.NUMBER_TYPE,) def __init__(self, min=None, max=None, description=None): super(Range, self).__init__(description) self.min = min self.max = max for param in (min, max): if not isinstance(param, (float, int, long, type(None))): raise InvalidSchemaError(_('min/max must be numeric')) if min is max is None: raise InvalidSchemaError( _('A range constraint must have a min value and/or a max ' 'value specified.')) def _str(self): if self.max is None: fmt = _('The value must be at least %(min)s.') elif self.min is None: fmt = _('The value must be no greater than %(max)s.') else: fmt = _('The value must be in the range %(min)s to %(max)s.') return fmt % self._constraint() def _err_msg(self, value): return '%s is out of range (min: %s, max: %s)' % (value, self.min, self.max) def _is_valid(self, value, context): value = Schema.str_to_num(value) if self.min is not None: if value < self.min: return False if self.max is not None: if value > self.max: return False return True def _constraint(self): def constraints(): if self.min is not None: yield self.MIN, self.min if self.max is not None: yield self.MAX, self.max return dict(constraints()) class Length(Range): """ Constrain the length of values within a range. Serialises to JSON as:: { 'length': {'min': , 'max': }, 'description': } """ valid_types = (Schema.STRING_TYPE, Schema.LIST_TYPE, Schema.MAP_TYPE,) def __init__(self, min=None, max=None, description=None): if min is max is None: raise InvalidSchemaError( _('A length constraint must have a min value and/or a max ' 'value specified.')) super(Length, self).__init__(min, max, description) for param in (min, max): if not isinstance(param, (int, long, type(None))): msg = _('min/max length must be integral') raise InvalidSchemaError(msg) def _str(self): if self.max is None: fmt = _('The length must be at least %(min)s.') elif self.min is None: fmt = _('The length must be no greater than %(max)s.') else: fmt = _('The length must be in the range %(min)s to %(max)s.') return fmt % self._constraint() def _err_msg(self, value): return 'length (%d) is out of range (min: %s, max: %s)' % (len(value), self.min, self.max) def _is_valid(self, value, context): return super(Length, self)._is_valid(len(value), context) class AllowedValues(Constraint): """ Constrain values to a predefined set. Serialises to JSON as:: { 'allowed_values': [, , ...], 'description': } """ valid_types = (Schema.STRING_TYPE, Schema.INTEGER_TYPE, Schema.NUMBER_TYPE, Schema.BOOLEAN_TYPE, Schema.LIST_TYPE,) def __init__(self, allowed, description=None): super(AllowedValues, self).__init__(description) if (not isinstance(allowed, collections.Sequence) or isinstance(allowed, basestring)): raise InvalidSchemaError(_('AllowedValues must be a list')) self.allowed = tuple(allowed) def _str(self): allowed = ', '.join(str(a) for a in self.allowed) return _('Allowed values: %s') % allowed def _err_msg(self, value): allowed = '[%s]' % ', '.join(str(a) for a in self.allowed) return '"%s" is not an allowed value %s' % (value, allowed) def _is_valid(self, value, context): # For list values, check if all elements of the list are contained # in allowed list. if isinstance(value, list): return all(v in self.allowed for v in value) return value in self.allowed def _constraint(self): return list(self.allowed) class AllowedPattern(Constraint): """ Constrain values to a predefined regular expression pattern. Serialises to JSON as:: { 'allowed_pattern': , 'description': } """ valid_types = (Schema.STRING_TYPE,) def __init__(self, pattern, description=None): super(AllowedPattern, self).__init__(description) if not isinstance(pattern, basestring): raise InvalidSchemaError(_('AllowedPattern must be a string')) self.pattern = pattern self.match = re.compile(pattern).match def _str(self): return _('Value must match pattern: %s') % self.pattern def _err_msg(self, value): return '"%s" does not match pattern "%s"' % (value, self.pattern) def _is_valid(self, value, context): match = self.match(value) return match is not None and match.end() == len(value) def _constraint(self): return self.pattern class CustomConstraint(Constraint): """ A constraint delegating validation to an external class. """ valid_types = (Schema.STRING_TYPE, Schema.INTEGER_TYPE, Schema.NUMBER_TYPE, Schema.BOOLEAN_TYPE, Schema.LIST_TYPE) def __init__(self, name, description=None, environment=None): super(CustomConstraint, self).__init__(description) self.name = name self._environment = environment self._custom_constraint = None def _constraint(self): return self.name @property def custom_constraint(self): if self._custom_constraint is None: if self._environment is None: self._environment = resources.global_env() constraint_class = self._environment.get_constraint(self.name) if constraint_class: self._custom_constraint = constraint_class() return self._custom_constraint def _str(self): message = getattr(self.custom_constraint, "message", None) if not message: message = _('Value must be of type %s') % self.name return message def _err_msg(self, value): constraint = self.custom_constraint if constraint is None: return _('"%(value)s" does not validate %(name)s ' '(constraint not found)') % { "value": value, "name": self.name} error = getattr(constraint, "error", None) if error: return error(value) return _('"%(value)s" does not validate %(name)s') % { "value": value, "name": self.name} def _is_valid(self, value, context): constraint = self.custom_constraint if not constraint: return False return constraint.validate(value, context) heat-2014.1.5/heat/engine/properties.py0000664000567000056700000003753712540642614021004 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. import collections from heat.common import exception from heat.engine import parameters from heat.engine import support from heat.engine import constraints as constr SCHEMA_KEYS = ( REQUIRED, IMPLEMENTED, DEFAULT, TYPE, SCHEMA, ALLOWED_PATTERN, MIN_VALUE, MAX_VALUE, ALLOWED_VALUES, MIN_LENGTH, MAX_LENGTH, DESCRIPTION, UPDATE_ALLOWED, ) = ( 'Required', 'Implemented', 'Default', 'Type', 'Schema', 'AllowedPattern', 'MinValue', 'MaxValue', 'AllowedValues', 'MinLength', 'MaxLength', 'Description', 'UpdateAllowed', ) class Schema(constr.Schema): """ Schema class for validating resource properties. This class is used for defining schema constraints for resource properties. It inherits generic validation features from the base Schema class and add processing that is specific to resource properties. """ KEYS = ( TYPE, DESCRIPTION, DEFAULT, SCHEMA, REQUIRED, CONSTRAINTS, UPDATE_ALLOWED ) = ( 'type', 'description', 'default', 'schema', 'required', 'constraints', 'update_allowed' ) def __init__(self, data_type, description=None, default=None, schema=None, required=False, constraints=[], implemented=True, update_allowed=False, support_status=support.SupportStatus()): super(Schema, self).__init__(data_type, description, default, schema, required, constraints) self.implemented = implemented self.update_allowed = update_allowed self.support_status = support_status # validate structural correctness of schema itself self.validate() @classmethod def from_legacy(cls, schema_dict): """ Return a Property Schema object from a legacy schema dictionary. """ # Check for fully-fledged Schema objects if isinstance(schema_dict, cls): return schema_dict unknown = [k for k in schema_dict if k not in SCHEMA_KEYS] if unknown: raise constr.InvalidSchemaError(_('Unknown key(s) %s') % unknown) def constraints(): def get_num(key): val = schema_dict.get(key) if val is not None: val = Schema.str_to_num(val) return val if MIN_VALUE in schema_dict or MAX_VALUE in schema_dict: yield constr.Range(get_num(MIN_VALUE), get_num(MAX_VALUE)) if MIN_LENGTH in schema_dict or MAX_LENGTH in schema_dict: yield constr.Length(get_num(MIN_LENGTH), get_num(MAX_LENGTH)) if ALLOWED_VALUES in schema_dict: yield constr.AllowedValues(schema_dict[ALLOWED_VALUES]) if ALLOWED_PATTERN in schema_dict: yield constr.AllowedPattern(schema_dict[ALLOWED_PATTERN]) try: data_type = schema_dict[TYPE] except KeyError: raise constr.InvalidSchemaError(_('No %s specified') % TYPE) if SCHEMA in schema_dict: if data_type == Schema.LIST: ss = cls.from_legacy(schema_dict[SCHEMA]) elif data_type == Schema.MAP: schema_dicts = schema_dict[SCHEMA].items() ss = dict((n, cls.from_legacy(sd)) for n, sd in schema_dicts) else: raise constr.InvalidSchemaError(_('%(schema)s supplied for ' ' %(type)s %(data)s') % dict(schema=SCHEMA, type=TYPE, data=data_type)) else: ss = None return cls(data_type, description=schema_dict.get(DESCRIPTION), default=schema_dict.get(DEFAULT), schema=ss, required=schema_dict.get(REQUIRED, False), constraints=list(constraints()), implemented=schema_dict.get(IMPLEMENTED, True), update_allowed=schema_dict.get(UPDATE_ALLOWED, False)) @classmethod def from_parameter(cls, param): """ Return a Property Schema corresponding to a Parameter Schema. Convert a parameter schema from a provider template to a property Schema for the corresponding resource facade. """ # map param types to property types param_type_map = { param.STRING: cls.STRING, param.NUMBER: cls.NUMBER, param.LIST: cls.LIST, param.MAP: cls.MAP } # make update_allowed true by default on TemplateResources # as the template should deal with this. return cls(data_type=param_type_map.get(param.type, cls.MAP), description=param.description, required=param.required, constraints=param.constraints, update_allowed=True) def __getitem__(self, key): if key == self.UPDATE_ALLOWED: return self.update_allowed else: return super(Schema, self).__getitem__(key) raise KeyError(key) def schemata(schema_dicts): """ Return dictionary of Schema objects for given dictionary of schemata. The input schemata are converted from the legacy (dictionary-based) format to Schema objects where necessary. """ return dict((n, Schema.from_legacy(s)) for n, s in schema_dicts.items()) class Property(object): def __init__(self, schema, name=None, context=None): self.schema = Schema.from_legacy(schema) self.name = name self.context = context def required(self): return self.schema.required def implemented(self): return self.schema.implemented def update_allowed(self): return self.schema.update_allowed def has_default(self): return self.schema.default is not None def default(self): return self.schema.default def type(self): return self.schema.type def support_status(self): return self.schema.support_status def _validate_integer(self, value): if value is None: value = self.has_default() and self.default() or 0 try: value = int(value) except ValueError: raise TypeError(_("Value '%s' is not an integer") % value) else: return value def _validate_number(self, value): if value is None: value = self.has_default() and self.default() or 0 return Schema.str_to_num(value) def _validate_string(self, value): if value is None: value = self.has_default() and self.default() or '' if not isinstance(value, basestring): raise ValueError(_('Value must be a string')) return value def _validate_children(self, child_values, keys=None): if self.schema.schema is not None: if keys is None: keys = list(self.schema.schema) schemata = dict((k, self.schema.schema[k]) for k in keys) properties = Properties(schemata, dict(child_values), parent_name=self.name, context=self.context) properties.validate() return ((k, properties[k]) for k in keys) else: return child_values def _validate_map(self, value): if value is None: value = self.has_default() and self.default() or {} if not isinstance(value, collections.Mapping): raise TypeError(_('"%s" is not a map') % value) return dict(self._validate_children(value.iteritems())) def _validate_list(self, value): if value is None: value = self.has_default() and self.default() or [] if (not isinstance(value, collections.Sequence) or isinstance(value, basestring)): raise TypeError(_('"%s" is not a list') % repr(value)) return [v[1] for v in self._validate_children(enumerate(value), range(len(value)))] def _validate_bool(self, value): if value is None: value = self.has_default() and self.default() or False if isinstance(value, bool): return value normalised = value.lower() if normalised not in ['true', 'false']: raise ValueError(_('"%s" is not a valid boolean') % normalised) return normalised == 'true' def _validate_data_type(self, value): t = self.type() if t == Schema.STRING: return self._validate_string(value) elif t == Schema.INTEGER: return self._validate_integer(value) elif t == Schema.NUMBER: return self._validate_number(value) elif t == Schema.MAP: return self._validate_map(value) elif t == Schema.LIST: return self._validate_list(value) elif t == Schema.BOOLEAN: return self._validate_bool(value) def validate_data(self, value): value = self._validate_data_type(value) self.schema.validate_constraints(value, self.context) return value class Properties(collections.Mapping): def __init__(self, schema, data, resolver=lambda d: d, parent_name=None, context=None): self.props = dict((k, Property(s, k, context)) for k, s in schema.items()) self.resolve = resolver self.data = data if parent_name is None: self.error_prefix = '' else: self.error_prefix = '%s: ' % parent_name self.context = context @staticmethod def schema_from_params(params_snippet): """ Convert a template snippet that defines parameters into a properties schema :param params_snippet: parameter definition from a template :returns: an equivalent properties schema for the specified params """ if params_snippet: return dict((n, Schema.from_parameter(p)) for n, p in params_snippet.items()) return {} def validate(self, with_value=True): for (key, prop) in self.props.items(): if with_value: try: self[key] except ValueError as e: msg = _("Property error : %s") % str(e) raise exception.StackValidationFailed(message=msg) # are there unimplemented Properties if not prop.implemented() and key in self.data: msg = _("Property %s not implemented yet") % key raise exception.StackValidationFailed(message=msg) for key in self.data: if key not in self.props: msg = _("Unknown Property %s") % key raise exception.StackValidationFailed(message=msg) def __getitem__(self, key): if key not in self: raise KeyError(_('%(prefix)sInvalid Property %(key)s') % {'prefix': self.error_prefix, 'key': key}) prop = self.props[key] if key in self.data: try: value = self.resolve(self.data[key]) return prop.validate_data(value) # the resolver function could raise any number of exceptions, # so handle this generically except Exception as e: raise ValueError('%s%s %s' % (self.error_prefix, key, str(e))) elif prop.has_default(): return prop.default() elif prop.required(): raise ValueError(_('%(prefix)sProperty %(key)s not assigned') % {'prefix': self.error_prefix, 'key': key}) def __len__(self): return len(self.props) def __contains__(self, key): return key in self.props def __iter__(self): return iter(self.props) @staticmethod def _param_def_from_prop(schema): """ Return a template parameter definition corresponding to a property. """ param_type_map = { schema.INTEGER: parameters.Schema.NUMBER, schema.STRING: parameters.Schema.STRING, schema.NUMBER: parameters.Schema.NUMBER, schema.BOOLEAN: parameters.Schema.STRING, schema.MAP: parameters.Schema.MAP, schema.LIST: parameters.Schema.LIST, } def param_items(): yield parameters.TYPE, param_type_map[schema.type] if schema.description is not None: yield parameters.DESCRIPTION, schema.description if schema.default is not None: yield parameters.DEFAULT, schema.default for constraint in schema.constraints: if isinstance(constraint, constr.Length): if constraint.min is not None: yield parameters.MIN_LENGTH, constraint.min if constraint.max is not None: yield parameters.MAX_LENGTH, constraint.max elif isinstance(constraint, constr.Range): if constraint.min is not None: yield parameters.MIN_VALUE, constraint.min if constraint.max is not None: yield parameters.MAX_VALUE, constraint.max elif isinstance(constraint, constr.AllowedValues): yield parameters.ALLOWED_VALUES, list(constraint.allowed) elif isinstance(constraint, constr.AllowedPattern): yield parameters.ALLOWED_PATTERN, constraint.pattern if schema.type == schema.BOOLEAN: yield parameters.ALLOWED_VALUES, ['True', 'true', 'False', 'false'] return dict(param_items()) @staticmethod def _prop_def_from_prop(name, schema): """ Return a provider template property definition for a property. """ if schema.type == Schema.LIST: return {'Fn::Split': [',', {'Ref': name}]} else: return {'Ref': name} @classmethod def schema_to_parameters_and_properties(cls, schema): '''Generates properties with params resolved for a resource's properties_schema. :param schema: A resource type's properties_schema :returns: A tuple of params and properties dicts ex: input: {'foo': {'Type': 'String'}} output: {'foo': {'Type': 'String'}}, {'foo': {'Ref': 'foo'}} ex: input: {'foo': {'Type': 'List'}, 'bar': {'Type': 'Map'}} output: {'foo': {'Type': 'CommaDelimitedList'} 'bar': {'Type': 'Json'}}, {'foo': {'Fn::Split': {'Ref': 'foo'}}, 'bar': {'Ref': 'bar'}} ''' def param_prop_def_items(name, schema): param_def = cls._param_def_from_prop(schema) prop_def = cls._prop_def_from_prop(name, schema) return (name, param_def), (name, prop_def) param_prop_defs = [param_prop_def_items(n, s) for n, s in schemata(schema).iteritems() if s.implemented] param_items, prop_items = zip(*param_prop_defs) return dict(param_items), dict(prop_items) heat-2014.1.5/heat/engine/__init__.py0000664000567000056700000000000012540642611020313 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/function.py0000664000567000056700000000677212540642614020432 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. import abc import collections class Function(object): """ Abstract base class for template functions. """ __metaclass__ = abc.ABCMeta def __init__(self, stack, fn_name, args): """ Initialise with a Stack, the function name and the arguments. All functions take the form of a single-item map in JSON:: { : } """ super(Function, self).__init__() self.stack = stack self.fn_name = fn_name self.args = args @abc.abstractmethod def result(self): """ Return the result of resolving the function. Function subclasses must override this method to calculate their results. """ return {self.fn_name: self.args} def __reduce__(self): """ Return a representation of the function suitable for pickling. This allows the copy module (which works by pickling and then unpickling objects) to copy a template. Functions in the copy will return to their original (JSON) form (i.e. a single-element map). """ return dict, ([(self.fn_name, self.args)],) def __repr__(self): """ Return a string representation of the function. The representation includes the function name, arguments and result (if available), as well as the name of the function class. """ try: result = repr(self.result()) except (TypeError, ValueError): result = '???' fntype = type(self) classname = '.'.join(filter(None, (getattr(fntype, attr, '') for attr in ('__module__', '__name__')))) return '<%s {%s: %r} -> %s>' % (classname, self.fn_name, self.args, result) def __eq__(self, other): """Compare the result of this function for equality.""" try: result = self.result() if isinstance(other, Function): return result == other.result() else: return result == other except (TypeError, ValueError): return NotImplemented def __ne__(self, other): """Compare the result of this function for inequality.""" eq = self.__eq__(other) if eq is NotImplemented: return NotImplemented return not eq def resolve(snippet): while isinstance(snippet, Function): snippet = snippet.result() if isinstance(snippet, collections.Mapping): return dict((k, resolve(v)) for k, v in snippet.items()) elif (not isinstance(snippet, basestring) and isinstance(snippet, collections.Iterable)): return [resolve(v) for v in snippet] return snippet heat-2014.1.5/heat/engine/api.py0000664000567000056700000003014412540642614017344 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. from heat.common import template_format from heat.rpc import api from heat.openstack.common import timeutils from heat.engine import constraints as constr from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) def extract_args(params): ''' Extract any arguments passed as parameters through the API and return them as a dictionary. This allows us to filter the passed args and do type conversion where appropriate ''' kwargs = {} timeout_mins = params.get(api.PARAM_TIMEOUT) if timeout_mins not in ('0', 0, None): try: timeout = int(timeout_mins) except (ValueError, TypeError): logger.exception(_('Timeout conversion failed')) else: if timeout > 0: kwargs[api.PARAM_TIMEOUT] = timeout else: raise ValueError(_('Invalid timeout value %s') % timeout) if api.PARAM_DISABLE_ROLLBACK in params: disable_rollback = params.get(api.PARAM_DISABLE_ROLLBACK) if str(disable_rollback).lower() == 'true': kwargs[api.PARAM_DISABLE_ROLLBACK] = True elif str(disable_rollback).lower() == 'false': kwargs[api.PARAM_DISABLE_ROLLBACK] = False else: raise ValueError(_('Unexpected value for parameter' ' %(name)s : %(value)s') % dict(name=api.PARAM_DISABLE_ROLLBACK, value=disable_rollback)) adopt_data = params.get(api.PARAM_ADOPT_STACK_DATA) if adopt_data: adopt_data = template_format.simple_parse(adopt_data) if not isinstance(adopt_data, dict): raise ValueError( _('Unexpected adopt data "%s". Adopt data must be a dict.') % adopt_data) kwargs[api.PARAM_ADOPT_STACK_DATA] = adopt_data return kwargs def format_stack_outputs(stack, outputs): ''' Return a representation of the given output template for the given stack that matches the API output expectations. ''' def format_stack_output(k): return {api.OUTPUT_DESCRIPTION: outputs[k].get('Description', 'No description given'), api.OUTPUT_KEY: k, api.OUTPUT_VALUE: stack.output(k)} return [format_stack_output(key) for key in outputs] def format_stack(stack): ''' Return a representation of the given stack that matches the API output expectations. ''' updated_time = stack.updated_time and timeutils.isotime(stack.updated_time) info = { api.STACK_NAME: stack.name, api.STACK_ID: dict(stack.identifier()), api.STACK_CREATION_TIME: timeutils.isotime(stack.created_time), api.STACK_UPDATED_TIME: updated_time, api.STACK_NOTIFICATION_TOPICS: [], # TODO Not implemented yet api.STACK_PARAMETERS: stack.parameters.map(str), api.STACK_DESCRIPTION: stack.t[stack.t.DESCRIPTION], api.STACK_TMPL_DESCRIPTION: stack.t[stack.t.DESCRIPTION], api.STACK_ACTION: stack.action or '', api.STACK_STATUS: stack.status or '', api.STACK_STATUS_DATA: stack.status_reason, api.STACK_CAPABILITIES: [], # TODO Not implemented yet api.STACK_DISABLE_ROLLBACK: stack.disable_rollback, api.STACK_TIMEOUT: stack.timeout_mins, } # only show the outputs on a completely created or updated stack if (stack.action != stack.DELETE and stack.status == stack.COMPLETE): info[api.STACK_OUTPUTS] = format_stack_outputs(stack, stack.outputs) return info def format_stack_resource(resource, detail=True): ''' Return a representation of the given resource that matches the API output expectations. ''' last_updated_time = resource.updated_time or resource.created_time res = { api.RES_UPDATED_TIME: timeutils.isotime(last_updated_time), api.RES_NAME: resource.name, api.RES_PHYSICAL_ID: resource.resource_id or '', api.RES_METADATA: resource.metadata, api.RES_ACTION: resource.action, api.RES_STATUS: resource.status, api.RES_STATUS_DATA: resource.status_reason, api.RES_TYPE: resource.t['Type'], api.RES_ID: dict(resource.identifier()), api.RES_STACK_ID: dict(resource.stack.identifier()), api.RES_STACK_NAME: resource.stack.name, api.RES_REQUIRED_BY: resource.required_by(), } if detail: res[api.RES_DESCRIPTION] = resource.parsed_template('Description', '') res[api.RES_METADATA] = resource.metadata return res def format_stack_preview(stack): def format_resource(res): if isinstance(res, list): return map(format_resource, res) return format_stack_resource(res) fmt_stack = format_stack(stack) fmt_resources = map(format_resource, stack.preview_resources()) fmt_stack['resources'] = fmt_resources return fmt_stack def format_event(event): stack_identifier = event.stack.identifier() result = { api.EVENT_ID: dict(event.identifier()), api.EVENT_STACK_ID: dict(stack_identifier), api.EVENT_STACK_NAME: stack_identifier.stack_name, api.EVENT_TIMESTAMP: timeutils.isotime(event.timestamp), api.EVENT_RES_NAME: event.resource_name, api.EVENT_RES_PHYSICAL_ID: event.physical_resource_id, api.EVENT_RES_ACTION: event.action, api.EVENT_RES_STATUS: event.status, api.EVENT_RES_STATUS_DATA: event.reason, api.EVENT_RES_TYPE: event.resource_type, api.EVENT_RES_PROPERTIES: event.resource_properties, } return result def format_notification_body(stack): # some other posibilities here are: # - template name # - template size # - resource count if stack.status is not None and stack.action is not None: state = '_'.join(stack.state) else: state = 'Unknown' result = { api.NOTIFY_TENANT_ID: stack.context.tenant_id, api.NOTIFY_USER_ID: stack.context.user, api.NOTIFY_STACK_ID: stack.identifier().arn(), api.NOTIFY_STACK_NAME: stack.name, api.NOTIFY_STATE: state, api.NOTIFY_STATE_REASON: stack.status_reason, api.NOTIFY_CREATE_AT: timeutils.isotime(stack.created_time), } return result def format_watch(watch): result = { api.WATCH_ACTIONS_ENABLED: watch.rule.get(api.RULE_ACTIONS_ENABLED), api.WATCH_ALARM_ACTIONS: watch.rule.get(api.RULE_ALARM_ACTIONS), api.WATCH_TOPIC: watch.rule.get(api.RULE_TOPIC), api.WATCH_UPDATED_TIME: timeutils.isotime(watch.updated_at), api.WATCH_DESCRIPTION: watch.rule.get(api.RULE_DESCRIPTION), api.WATCH_NAME: watch.name, api.WATCH_COMPARISON: watch.rule.get(api.RULE_COMPARISON), api.WATCH_DIMENSIONS: watch.rule.get(api.RULE_DIMENSIONS) or [], api.WATCH_PERIODS: watch.rule.get(api.RULE_PERIODS), api.WATCH_INSUFFICIENT_ACTIONS: watch.rule.get(api.RULE_INSUFFICIENT_ACTIONS), api.WATCH_METRIC_NAME: watch.rule.get(api.RULE_METRIC_NAME), api.WATCH_NAMESPACE: watch.rule.get(api.RULE_NAMESPACE), api.WATCH_OK_ACTIONS: watch.rule.get(api.RULE_OK_ACTIONS), api.WATCH_PERIOD: watch.rule.get(api.RULE_PERIOD), api.WATCH_STATE_REASON: watch.rule.get(api.RULE_STATE_REASON), api.WATCH_STATE_REASON_DATA: watch.rule.get(api.RULE_STATE_REASON_DATA), api.WATCH_STATE_UPDATED_TIME: timeutils.isotime( watch.rule.get(api.RULE_STATE_UPDATED_TIME)), api.WATCH_STATE_VALUE: watch.state, api.WATCH_STATISTIC: watch.rule.get(api.RULE_STATISTIC), api.WATCH_THRESHOLD: watch.rule.get(api.RULE_THRESHOLD), api.WATCH_UNIT: watch.rule.get(api.RULE_UNIT), api.WATCH_STACK_ID: watch.stack_id } return result def format_watch_data(wd): # Demangle DB format data into something more easily used in the API # We are expecting a dict with exactly two items, Namespace and # a metric key namespace = wd.data['Namespace'] metric = [(k, v) for k, v in wd.data.items() if k != 'Namespace'] if len(metric) == 1: metric_name, metric_data = metric[0] else: logger.error(_("Unexpected number of keys in watch_data.data!")) return result = { api.WATCH_DATA_ALARM: wd.watch_rule.name, api.WATCH_DATA_METRIC: metric_name, api.WATCH_DATA_TIME: timeutils.isotime(wd.created_at), api.WATCH_DATA_NAMESPACE: namespace, api.WATCH_DATA: metric_data } return result def format_validate_parameter(param): """ Format a template parameter for validate template API call Formats a template parameter and its schema information from the engine's internal representation (i.e. a Parameter object and its associated Schema object) to a representation expected by the current API (for example to be compatible to CFN syntax). """ # map of Schema object types to API expected types schema_to_api_types = { param.schema.STRING: api.PARAM_TYPE_STRING, param.schema.NUMBER: api.PARAM_TYPE_NUMBER, param.schema.LIST: api.PARAM_TYPE_COMMA_DELIMITED_LIST, param.schema.MAP: api.PARAM_TYPE_JSON } res = { api.PARAM_TYPE: schema_to_api_types.get(param.schema.type, param.schema.type), api.PARAM_DESCRIPTION: param.description(), api.PARAM_NO_ECHO: 'true' if param.hidden() else 'false', api.PARAM_LABEL: param.label() } if param.has_value(): res[api.PARAM_DEFAULT] = param.value() constraint_description = [] # build constraints for c in param.schema.constraints: if isinstance(c, constr.Length): if c.min is not None: res[api.PARAM_MIN_LENGTH] = c.min if c.max is not None: res[api.PARAM_MAX_LENGTH] = c.max elif isinstance(c, constr.Range): if c.min is not None: res[api.PARAM_MIN_VALUE] = c.min if c.max is not None: res[api.PARAM_MAX_VALUE] = c.max elif isinstance(c, constr.AllowedValues): res[api.PARAM_ALLOWED_VALUES] = list(c.allowed) elif isinstance(c, constr.AllowedPattern): res[api.PARAM_ALLOWED_PATTERN] = c.pattern if c.description: constraint_description.append(c.description) if constraint_description: res[api.PARAM_CONSTRAINT_DESCRIPTION] = " ".join( constraint_description) return res def format_software_config(sc): if sc is None: return result = { api.SOFTWARE_CONFIG_ID: sc.id, api.SOFTWARE_CONFIG_NAME: sc.name, api.SOFTWARE_CONFIG_GROUP: sc.group, api.SOFTWARE_CONFIG_CONFIG: sc.config['config'], api.SOFTWARE_CONFIG_INPUTS: sc.config['inputs'], api.SOFTWARE_CONFIG_OUTPUTS: sc.config['outputs'], api.SOFTWARE_CONFIG_OPTIONS: sc.config['options'] } return result def format_software_deployment(sd): if sd is None: return result = { api.SOFTWARE_DEPLOYMENT_ID: sd.id, api.SOFTWARE_DEPLOYMENT_SERVER_ID: sd.server_id, api.SOFTWARE_DEPLOYMENT_INPUT_VALUES: sd.input_values, api.SOFTWARE_DEPLOYMENT_OUTPUT_VALUES: sd.output_values, api.SOFTWARE_DEPLOYMENT_ACTION: sd.action, api.SOFTWARE_DEPLOYMENT_STATUS: sd.status, api.SOFTWARE_DEPLOYMENT_STATUS_REASON: sd.status_reason, api.SOFTWARE_DEPLOYMENT_CONFIG_ID: sd.config.id, } return result heat-2014.1.5/heat/engine/plugin_manager.py0000664000567000056700000001035112540642614021561 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # # 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. import collections import itertools import sys from oslo.config import cfg from heat.openstack.common import log from heat.common import plugin_loader logger = log.getLogger(__name__) class PluginManager(object): '''A class for managing plugin modules.''' def __init__(self, *extra_packages): '''Initialise the Heat Engine plugin package, and any others. The heat.engine.plugins package is always created, if it does not exist, from the plugin directories specified in the config file, and searched for modules. In addition, any extra packages specified are also searched for modules. e.g. >>> PluginManager('heat.engine.resources') will load all modules in the heat.engine.resources package as well as any user-supplied plugin modules. ''' def packages(): for package_name in extra_packages: yield sys.modules[package_name] cfg.CONF.import_opt('plugin_dirs', 'heat.common.config') yield plugin_loader.create_subpackage(cfg.CONF.plugin_dirs, 'heat.engine') def modules(): pkg_modules = itertools.imap(plugin_loader.load_modules, packages()) return itertools.chain.from_iterable(pkg_modules) self.modules = list(modules()) def map_to_modules(self, function): '''Iterate over the results of calling a function on every module.''' return itertools.imap(function, self.modules) class PluginMapping(object): '''A class for managing plugin mappings.''' def __init__(self, names, *args, **kwargs): '''Initialise with the mapping name(s) and arguments. `names` can be a single name or a list of names. The first name found in a given module is the one used. Each module is searched for a function called _mapping() which is called to retrieve the mappings provided by that module. Any other arguments passed will be passed to the mapping functions. ''' if isinstance(names, basestring): names = [names] self.names = ['%s_mapping' % name for name in names] self.args = args self.kwargs = kwargs def load_from_module(self, module): '''Return the mapping specified in the given module. If no such mapping is specified, an empty dictionary is returned. ''' for mapping_name in self.names: mapping_func = getattr(module, mapping_name, None) if callable(mapping_func): fmt_data = {'mapping_name': mapping_name, 'module': module} try: mapping_dict = mapping_func(*self.args, **self.kwargs) except Exception: logger.error(_('Failed to load %(mapping_name)s ' 'from %(module)s') % fmt_data) raise else: if isinstance(mapping_dict, collections.Mapping): return mapping_dict elif mapping_dict is not None: logger.error(_('Invalid type for %(mapping_name)s ' 'from %(module)s') % fmt_data) return {} def load_all(self, plugin_manager): '''Iterate over the mappings from all modules in the plugin manager. Mappings are returned as a list of (key, value) tuples. ''' mod_dicts = plugin_manager.map_to_modules(self.load_from_module) return itertools.chain.from_iterable(d.iteritems() for d in mod_dicts) heat-2014.1.5/heat/engine/update.py0000664000567000056700000001660412540642614020062 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. import copy from heat.db import api as db_api from heat.engine import dependencies from heat.engine import resource from heat.engine import scheduler from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) class StackUpdate(object): """ A Task to perform the update of an existing stack to a new template. """ def __init__(self, existing_stack, new_stack, previous_stack, rollback=False): """Initialise with the existing stack and the new stack.""" self.existing_stack = existing_stack self.new_stack = new_stack self.previous_stack = previous_stack self.rollback = rollback self.existing_snippets = dict((n, r.parsed_template()) for n, r in self.existing_stack.items()) def __repr__(self): if self.rollback: return '%s Rollback' % str(self.existing_stack) else: return '%s Update' % str(self.existing_stack) @scheduler.wrappertask def __call__(self): """Return a co-routine that updates the stack.""" cleanup_prev = scheduler.DependencyTaskGroup( self.previous_stack.dependencies, self._remove_backup_resource, reverse=True) update = scheduler.DependencyTaskGroup(self.dependencies(), self._resource_update) if not self.rollback: yield cleanup_prev() try: yield update() finally: self.previous_stack.reset_dependencies() def _resource_update(self, res): if res.name in self.new_stack and self.new_stack[res.name] is res: return self._process_new_resource_update(res) else: return self._process_existing_resource_update(res) @scheduler.wrappertask def _remove_backup_resource(self, prev_res): if prev_res.state not in ((prev_res.INIT, prev_res.COMPLETE), (prev_res.DELETE, prev_res.COMPLETE)): logger.debug(_("Deleting backup resource %s") % prev_res.name) yield prev_res.destroy() @staticmethod def _exchange_stacks(existing_res, prev_res): db_api.resource_exchange_stacks(existing_res.stack.context, existing_res.id, prev_res.id) prev_stack, existing_stack = prev_res.stack, existing_res.stack prev_stack[existing_res.name] = existing_res existing_stack[prev_res.name] = prev_res @scheduler.wrappertask def _create_resource(self, new_res): res_name = new_res.name # Clean up previous resource if res_name in self.previous_stack: prev_res = self.previous_stack[res_name] if prev_res.state not in ((prev_res.INIT, prev_res.COMPLETE), (prev_res.DELETE, prev_res.COMPLETE)): # Swap in the backup resource if it is in a valid state, # instead of creating a new resource if prev_res.status == prev_res.COMPLETE: logger.debug(_("Swapping in backup Resource %s") % res_name) self._exchange_stacks(self.existing_stack[res_name], prev_res) return logger.debug(_("Deleting backup Resource %s") % res_name) yield prev_res.destroy() # Back up existing resource if res_name in self.existing_stack: logger.debug(_("Backing up existing Resource %s") % res_name) existing_res = self.existing_stack[res_name] self.previous_stack[res_name] = existing_res existing_res.state_set(existing_res.UPDATE, existing_res.COMPLETE) self.existing_stack[res_name] = new_res yield new_res.create() @scheduler.wrappertask def _process_new_resource_update(self, new_res): res_name = new_res.name if res_name in self.existing_stack: existing_res = self.existing_stack[res_name] try: yield self._update_in_place(existing_res, new_res) except resource.UpdateReplace: pass else: logger.info(_("Resource %(res_name)s for stack %(stack_name)s" " updated") % { 'res_name': res_name, 'stack_name': self.existing_stack.name}) return yield self._create_resource(new_res) def _update_in_place(self, existing_res, new_res): existing_snippet = self.existing_snippets[existing_res.name] prev_res = self.previous_stack.get(new_res.name) # Note the new resource snippet is resolved in the context # of the existing stack (which is the stack being updated) raw_snippet = copy.deepcopy(new_res.t) parsed_snippet = self.existing_stack.resolve_static_data(raw_snippet) new_snippet = self.existing_stack.resolve_runtime_data(parsed_snippet) return existing_res.update(new_snippet, existing_snippet, prev_resource=prev_res) @scheduler.wrappertask def _process_existing_resource_update(self, existing_res): res_name = existing_res.name if res_name in self.previous_stack: yield self._remove_backup_resource(self.previous_stack[res_name]) if res_name in self.new_stack: new_res = self.new_stack[res_name] if new_res.state == (new_res.INIT, new_res.COMPLETE): # Already updated in-place return if existing_res.stack is not self.previous_stack: yield existing_res.destroy() if res_name not in self.new_stack: del self.existing_stack[res_name] def dependencies(self): ''' Return a Dependencies object representing the dependencies between update operations to move from an existing stack definition to a new one. ''' existing_deps = self.existing_stack.dependencies new_deps = self.new_stack.dependencies def edges(): # Create/update the new stack's resources in create order for e in new_deps.graph().edges(): yield e # Destroy/cleanup the old stack's resources in delete order for e in existing_deps.graph(reverse=True).edges(): yield e # Don't cleanup old resources until after they have been replaced for name, res in self.existing_stack.iteritems(): if name in self.new_stack: yield (res, self.new_stack[name]) return dependencies.Dependencies(edges()) heat-2014.1.5/heat/engine/resources/0000775000567000056700000000000012540643116020227 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/nova_utils.py0000664000567000056700000003264112540642614022774 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. """Utilities for Resources that use the OpenStack Nova API.""" import email from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText import json import os import pkgutil import string from oslo.config import cfg import six from heat.common import exception from heat.engine import clients from heat.engine import scheduler from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils from heat.openstack.common import uuidutils logger = logging.getLogger(__name__) deferred_server_statuses = ['BUILD', 'HARD_REBOOT', 'PASSWORD', 'REBOOT', 'RESCUE', 'RESIZE', 'REVERT_RESIZE', 'SHUTOFF', 'SUSPENDED', 'VERIFY_RESIZE'] def refresh_server(server): ''' Refresh server's attributes and log warnings for non-critical API errors. ''' try: server.get() except clients.novaclient.exceptions.OverLimit as exc: msg = _("Server %(name)s (%(id)s) received an OverLimit " "response during server.get(): %(exception)s") logger.warning(msg % {'name': server.name, 'id': server.id, 'exception': str(exc)}) except clients.novaclient.exceptions.ClientException as exc: if ((getattr(exc, 'http_status', getattr(exc, 'code', None)) in (500, 503))): msg = _('Server "%(name)s" (%(id)s) received the following ' 'exception during server.get(): %(exception)s') logger.warning(msg % {'name': server.name, 'id': server.id, 'exception': str(exc)}) else: raise def get_image_id(nova_client, image_identifier): ''' Return an id for the specified image name or identifier. :param nova_client: the nova client to use :param image_identifier: image name or a UUID-like identifier :returns: the id of the requested :image_identifier: :raises: exception.ImageNotFound, exception.PhysicalResourceNameAmbiguity ''' if uuidutils.is_uuid_like(image_identifier): try: image_id = nova_client.images.get(image_identifier).id except clients.novaclient.exceptions.NotFound: logger.info(_("Image %s was not found in glance") % image_identifier) raise exception.ImageNotFound(image_name=image_identifier) else: try: image_list = nova_client.images.list() except clients.novaclient.exceptions.ClientException as ex: raise exception.Error( message=(_("Error retrieving image list from nova: %s") % str(ex))) image_names = dict( (o.id, o.name) for o in image_list if o.name == image_identifier) if len(image_names) == 0: logger.info(_("Image %s was not found in glance") % image_identifier) raise exception.ImageNotFound(image_name=image_identifier) elif len(image_names) > 1: logger.info(_("Multiple images %s were found in glance with name") % image_identifier) raise exception.PhysicalResourceNameAmbiguity( name=image_identifier) image_id = image_names.popitem()[0] return image_id def get_ip(server, net_type, ip_version): """Return the server's IP of the given type and version.""" if net_type in server.addresses: for ip in server.addresses[net_type]: if ip['version'] == ip_version: return ip['addr'] def get_flavor_id(nova_client, flavor): ''' Get the id for the specified flavor name. If the specified value is flavor id, just return it. :param nova_client: the nova client to use :param flavor: the name of the flavor to find :returns: the id of :flavor: :raises: exception.FlavorMissing ''' flavor_id = None flavor_list = nova_client.flavors.list() for o in flavor_list: if o.name == flavor: flavor_id = o.id break if o.id == flavor: flavor_id = o.id break if flavor_id is None: raise exception.FlavorMissing(flavor_id=flavor) return flavor_id def get_keypair(nova_client, key_name): ''' Get the public key specified by :key_name: :param nova_client: the nova client to use :param key_name: the name of the key to look for :returns: the keypair (name, public_key) for :key_name: :raises: exception.UserKeyPairMissing ''' for keypair in nova_client.keypairs.list(): if keypair.name == key_name: return keypair raise exception.UserKeyPairMissing(key_name=key_name) def build_userdata(resource, userdata=None, instance_user=None, user_data_format='HEAT_CFNTOOLS'): ''' Build multipart data blob for CloudInit which includes user-supplied Metadata, user data, and the required Heat in-instance configuration. :param resource: the resource implementation :type resource: heat.engine.Resource :param userdata: user data string :type userdata: str or None :param instance_user: the user to create on the server :type instance_user: string :param user_data_format: Format of user data to return :type user_data_format: string :returns: multipart mime as a string ''' if user_data_format == 'RAW': return userdata is_cfntools = user_data_format == 'HEAT_CFNTOOLS' is_software_config = user_data_format == 'SOFTWARE_CONFIG' def make_subpart(content, filename, subtype=None): if subtype is None: subtype = os.path.splitext(filename)[0] msg = MIMEText(content, _subtype=subtype) msg.add_header('Content-Disposition', 'attachment', filename=filename) return msg def read_cloudinit_file(fn): return pkgutil.get_data('heat', 'cloudinit/%s' % fn) if instance_user: config_custom_user = 'user: %s' % instance_user # FIXME(shadower): compatibility workaround for cloud-init 0.6.3. We # can drop this once we stop supporting 0.6.3 (which ships with Ubuntu # 12.04 LTS). # # See bug https://bugs.launchpad.net/heat/+bug/1257410 boothook_custom_user = r"""useradd -m %s echo -e '%s\tALL=(ALL)\tNOPASSWD: ALL' >> /etc/sudoers """ % (instance_user, instance_user) else: config_custom_user = '' boothook_custom_user = '' cloudinit_config = string.Template( read_cloudinit_file('config')).safe_substitute( add_custom_user=config_custom_user) cloudinit_boothook = string.Template( read_cloudinit_file('boothook.sh')).safe_substitute( add_custom_user=boothook_custom_user) attachments = [(cloudinit_config, 'cloud-config'), (cloudinit_boothook, 'boothook.sh', 'cloud-boothook'), (read_cloudinit_file('part_handler.py'), 'part-handler.py')] if is_cfntools: attachments.append((userdata, 'cfn-userdata', 'x-cfninitdata')) elif is_software_config: # attempt to parse userdata as a multipart message, and if it # is, add each part as an attachment userdata_parts = None try: userdata_parts = email.message_from_string(userdata) except: pass if userdata_parts and userdata_parts.is_multipart(): for part in userdata_parts.get_payload(): attachments.append((part.get_payload(), part.get_filename(), part.get_content_subtype())) else: attachments.append((userdata, 'userdata', 'x-shellscript')) if is_cfntools: attachments.append((read_cloudinit_file('loguserdata.py'), 'loguserdata.py', 'x-shellscript')) metadata = resource.metadata if metadata: attachments.append((json.dumps(metadata), 'cfn-init-data', 'x-cfninitdata')) attachments.append((cfg.CONF.heat_watch_server_url, 'cfn-watch-server', 'x-cfninitdata')) if is_cfntools: attachments.append((cfg.CONF.heat_metadata_server_url, 'cfn-metadata-server', 'x-cfninitdata')) # Create a boto config which the cfntools on the host use to know # where the cfn and cw API's are to be accessed cfn_url = urlutils.urlparse(cfg.CONF.heat_metadata_server_url) cw_url = urlutils.urlparse(cfg.CONF.heat_watch_server_url) is_secure = cfg.CONF.instance_connection_is_secure vcerts = cfg.CONF.instance_connection_https_validate_certificates boto_cfg = "\n".join(["[Boto]", "debug = 0", "is_secure = %s" % is_secure, "https_validate_certificates = %s" % vcerts, "cfn_region_name = heat", "cfn_region_endpoint = %s" % cfn_url.hostname, "cloudwatch_region_name = heat", "cloudwatch_region_endpoint = %s" % cw_url.hostname]) attachments.append((boto_cfg, 'cfn-boto-cfg', 'x-cfninitdata')) subparts = [make_subpart(*args) for args in attachments] mime_blob = MIMEMultipart(_subparts=subparts) return mime_blob.as_string() def delete_server(server): ''' Return a co-routine that deletes the server and waits for it to disappear from Nova. ''' server.delete() while True: yield try: refresh_server(server) except clients.novaclient.exceptions.NotFound: break @scheduler.wrappertask def resize(server, flavor, flavor_id): """Resize the server and then call check_resize task to verify.""" server.resize(flavor_id) yield check_resize(server, flavor, flavor_id) def rename(server, name): """Update the name for a server.""" server.update(name) def check_resize(server, flavor, flavor_id): """ Verify that a resizing server is properly resized. If that's the case, confirm the resize, if not raise an error. """ refresh_server(server) while server.status == 'RESIZE': yield refresh_server(server) if server.status == 'VERIFY_RESIZE': server.confirm_resize() else: raise exception.Error( _("Resizing to '%(flavor)s' failed, status '%(status)s'") % dict(flavor=flavor, status=server.status)) @scheduler.wrappertask def rebuild(server, image_id, preserve_ephemeral=False): """Rebuild the server and call check_rebuild to verify.""" server.rebuild(image_id, preserve_ephemeral=preserve_ephemeral) yield check_rebuild(server, image_id) def check_rebuild(server, image_id): """ Verify that a rebuilding server is rebuilt. Raise error if it ends up in an ERROR state. """ refresh_server(server) while server.status == 'REBUILD': yield refresh_server(server) if server.status == 'ERROR': raise exception.Error( _("Rebuilding server failed, status '%s'") % server.status) def meta_serialize(metadata): """ Serialize non-string metadata values before sending them to Nova. """ return dict((key, (value if isinstance(value, six.string_types) else json.dumps(value)) ) for (key, value) in metadata.items()) def meta_update(client, server, metadata): """Delete/Add the metadata in nova as needed.""" metadata = meta_serialize(metadata) current_md = server.metadata to_del = [key for key in current_md.keys() if key not in metadata] if len(to_del) > 0: client.servers.delete_meta(server, to_del) client.servers.set_meta(server, metadata) def server_to_ipaddress(client, server): ''' Return the server's IP address, fetching it from Nova. ''' try: server = client.servers.get(server) except clients.novaclient.exceptions.NotFound as ex: logger.warn(_('Instance (%(server)s) not found: %(ex)s') % { 'server': server, 'ex': str(ex)}) else: for n in server.networks: if len(server.networks[n]) > 0: return server.networks[n][0] def absolute_limits(nova_client): """Return the absolute limits as a dictionary.""" limits = nova_client.limits.get() return dict([(limit.name, limit.value) for limit in list(limits.absolute)]) heat-2014.1.5/heat/engine/resources/stack.py0000664000567000056700000001114512540642614021712 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. from requests import exceptions from heat.common import exception from heat.common import template_format from heat.common import urlfetch from heat.engine import properties from heat.engine.properties import Properties from heat.engine import stack_resource from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class NestedStack(stack_resource.StackResource): ''' A Resource representing a child stack to allow composition of templates. ''' PROPERTIES = ( TEMPLATE_URL, TIMEOUT_IN_MINS, PARAMETERS, ) = ( 'TemplateURL', 'TimeoutInMinutes', 'Parameters', ) properties_schema = { TEMPLATE_URL: properties.Schema( properties.Schema.STRING, _('The URL of a template that specifies the stack to be created ' 'as a resource.'), required=True, update_allowed=True ), TIMEOUT_IN_MINS: properties.Schema( properties.Schema.NUMBER, _('The length of time, in minutes, to wait for the nested stack ' 'creation.'), update_allowed=True ), PARAMETERS: properties.Schema( properties.Schema.MAP, _('The set of parameters passed to this nested stack.'), update_allowed=True ), } update_allowed_keys = ('Properties',) def child_template(self): try: template_data = urlfetch.get(self.properties[self.TEMPLATE_URL]) except (exceptions.RequestException, IOError) as r_exc: raise ValueError(_("Could not fetch remote template '%(url)s': " "%(exc)s") % {'url': self.properties[self.TEMPLATE_URL], 'exc': str(r_exc)}) return template_format.parse(template_data) def child_params(self): return self.properties[self.PARAMETERS] def handle_adopt(self, resource_data=None): return self._create_with_template(resource_adopt_data=resource_data) def handle_create(self): return self._create_with_template() def _create_with_template(self, resource_adopt_data=None): template = self.child_template() return self.create_with_template(template, self.child_params(), self.properties[self.TIMEOUT_IN_MINS], adopt_data=resource_adopt_data) def handle_delete(self): return self.delete_nested() def FnGetAtt(self, key): if key and not key.startswith('Outputs.'): raise exception.InvalidTemplateAttribute(resource=self.name, key=key) return self.get_output(key.partition('.')[-1]) def FnGetRefId(self): return self.nested().identifier().arn() def handle_update(self, json_snippet, tmpl_diff, prop_diff): # Nested stack template may be changed even if the prop_diff is empty. self.properties = Properties(self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) try: template_data = urlfetch.get(self.properties[self.TEMPLATE_URL]) except (exceptions.RequestException, IOError) as r_exc: raise ValueError(_("Could not fetch remote template '%(url)s': " "%(exc)s") % {'url': self.properties[self.TEMPLATE_URL], 'exc': str(r_exc)}) template = template_format.parse(template_data) return self.update_with_template(template, self.properties[self.PARAMETERS], self.properties[self.TIMEOUT_IN_MINS]) def resource_mapping(): return { 'AWS::CloudFormation::Stack': NestedStack, } heat-2014.1.5/heat/engine/resources/autoscaling.py0000664000567000056700000012340412540642614023120 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. import functools import json import math from heat.common import exception from heat.common import timeutils as iso8601utils from heat.engine import constraints from heat.engine import environment from heat.engine import function from heat.engine.notification import autoscaling as notification from heat.engine import properties from heat.engine.properties import Properties from heat.engine import resource from heat.engine import scheduler from heat.engine import signal_responder from heat.engine import stack_resource from heat.openstack.common import excutils from heat.openstack.common import log as logging from heat.openstack.common import timeutils from heat.scaling import template logger = logging.getLogger(__name__) (SCALED_RESOURCE_TYPE,) = ('OS::Heat::ScaledResource',) (EXACT_CAPACITY, CHANGE_IN_CAPACITY, PERCENT_CHANGE_IN_CAPACITY) = ( 'ExactCapacity', 'ChangeInCapacity', 'PercentChangeInCapacity') class CooldownMixin(object): ''' Utility class to encapsulate Cooldown related logic which is shared between AutoScalingGroup and ScalingPolicy ''' def _cooldown_inprogress(self): inprogress = False try: # Negative values don't make sense, so they are clamped to zero cooldown = max(0, self.properties[self.COOLDOWN]) except TypeError: # If not specified, it will be None, same as cooldown == 0 cooldown = 0 metadata = self.metadata if metadata and cooldown != 0: last_adjust = metadata.keys()[0] if not timeutils.is_older_than(last_adjust, cooldown): inprogress = True return inprogress def _cooldown_timestamp(self, reason): # Save resource metadata with a timestamp and reason # If we wanted to implement the AutoScaling API like AWS does, # we could maintain event history here, but since we only need # the latest event for cooldown, just store that for now metadata = {timeutils.strtime(): reason} self.metadata = metadata class InstanceGroup(stack_resource.StackResource): PROPERTIES = ( AVAILABILITY_ZONES, LAUNCH_CONFIGURATION_NAME, SIZE, LOAD_BALANCER_NAMES, TAGS, ) = ( 'AvailabilityZones', 'LaunchConfigurationName', 'Size', 'LoadBalancerNames', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) _ROLLING_UPDATE_SCHEMA_KEYS = ( MIN_INSTANCES_IN_SERVICE, MAX_BATCH_SIZE, PAUSE_TIME ) = ( 'MinInstancesInService', 'MaxBatchSize', 'PauseTime' ) _UPDATE_POLICY_SCHEMA_KEYS = (ROLLING_UPDATE,) = ('RollingUpdate',) properties_schema = { AVAILABILITY_ZONES: properties.Schema( properties.Schema.LIST, _('Not Implemented.'), required=True ), LAUNCH_CONFIGURATION_NAME: properties.Schema( properties.Schema.STRING, _('Name of LaunchConfiguration resource.'), required=True, update_allowed=True ), SIZE: properties.Schema( properties.Schema.INTEGER, _('Desired number of instances.'), required=True, update_allowed=True ), LOAD_BALANCER_NAMES: properties.Schema( properties.Schema.LIST, _('List of LoadBalancer resources.') ), TAGS: properties.Schema( properties.Schema.LIST, _('Tags to attach to this group.'), schema=properties.Schema( properties.Schema.MAP, schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), } update_allowed_keys = ('Properties', 'UpdatePolicy',) attributes_schema = { "InstanceList": _("A comma-delimited list of server ip addresses. " "(Heat extension).") } rolling_update_schema = { MIN_INSTANCES_IN_SERVICE: properties.Schema(properties.Schema.NUMBER, default=0), MAX_BATCH_SIZE: properties.Schema(properties.Schema.NUMBER, default=1), PAUSE_TIME: properties.Schema(properties.Schema.STRING, default='PT0S') } update_policy_schema = { ROLLING_UPDATE: properties.Schema(properties.Schema.MAP, schema=rolling_update_schema) } def __init__(self, name, json_snippet, stack): """ UpdatePolicy is currently only specific to InstanceGroup and AutoScalingGroup. Therefore, init is overridden to parse for the UpdatePolicy. """ super(InstanceGroup, self).__init__(name, json_snippet, stack) self.update_policy = Properties(self.update_policy_schema, self.t.get('UpdatePolicy', {}), parent_name=self.name, context=self.context) def validate(self): """ Add validation for update_policy """ super(InstanceGroup, self).validate() if self.update_policy: self.update_policy.validate() policy_name = self.update_policy_schema.keys()[0] if self.update_policy[policy_name]: pause_time = self.update_policy[policy_name][self.PAUSE_TIME] if iso8601utils.parse_isoduration(pause_time) > 3600: raise ValueError('Maximum PauseTime is 1 hour.') def get_instance_names(self): """Get a list of resource names of the instances in this InstanceGroup. Failed resources will be ignored. """ return [r.name for r in self.get_instances()] def get_instances(self): """Get a list of all the instance resources managed by this group. Sort the list of instances first by created_time then by name. """ resources = [] if self.nested(): resources = [resource for resource in self.nested().itervalues() if resource.status != resource.FAILED] return sorted(resources, key=lambda r: (r.created_time, r.name)) def _environment(self): """Return the environment for the nested stack.""" return { environment.PARAMETERS: {}, environment.RESOURCE_REGISTRY: { SCALED_RESOURCE_TYPE: 'AWS::EC2::Instance', }, } def handle_create(self): """Create a nested stack and add the initial resources to it.""" num_instances = self.properties[self.SIZE] initial_template = self._create_template(num_instances) return self.create_with_template(initial_template, self._environment()) def check_create_complete(self, task): """ When stack creation is done, update the load balancer. If any instances failed to be created, delete them. """ done = super(InstanceGroup, self).check_create_complete(task) if done: self._lb_reload() return done def handle_update(self, json_snippet, tmpl_diff, prop_diff): """ If Properties has changed, update self.properties, so we get the new values during any subsequent adjustment. """ if tmpl_diff: # parse update policy if 'UpdatePolicy' in tmpl_diff: self.update_policy = Properties( self.update_policy_schema, json_snippet.get('UpdatePolicy', {}), parent_name=self.name, context=self.context) if prop_diff: self.properties = Properties(self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) # Replace instances first if launch configuration has changed if (self.update_policy[self.ROLLING_UPDATE] and self.LAUNCH_CONFIGURATION_NAME in prop_diff): policy = self.update_policy[self.ROLLING_UPDATE] self._replace(policy[self.MIN_INSTANCES_IN_SERVICE], policy[self.MAX_BATCH_SIZE], policy[self.PAUSE_TIME]) # Get the current capacity, we may need to adjust if # Size has changed if self.SIZE in prop_diff: inst_list = self.get_instances() if len(inst_list) != self.properties[self.SIZE]: self.resize(self.properties[self.SIZE]) def _tags(self): """ Make sure that we add a tag that Ceilometer can pick up. These need to be prepended with 'metering.'. """ tags = self.properties.get(self.TAGS) or [] for t in tags: if t[self.TAG_KEY].startswith('metering.'): # the user has added one, don't add another. return tags return tags + [{self.TAG_KEY: 'metering.groupname', self.TAG_VALUE: self.FnGetRefId()}] def handle_delete(self): return self.delete_nested() def _get_instance_definition(self): conf_name = self.properties[self.LAUNCH_CONFIGURATION_NAME] conf = self.stack.resource_by_refid(conf_name) instance_definition = function.resolve(conf.t) instance_definition['Type'] = SCALED_RESOURCE_TYPE instance_definition['Properties']['Tags'] = self._tags() if self.properties.get('VPCZoneIdentifier'): instance_definition['Properties']['SubnetId'] = \ self.properties['VPCZoneIdentifier'][0] # resolve references within the context of this stack. return self.stack.resolve_runtime_data(instance_definition) def _get_instance_templates(self): """Get templates for resource instances.""" return [(instance.name, instance.t) for instance in self.get_instances()] def _create_template(self, num_instances, num_replace=0): """ Create a template to represent autoscaled instances. Also see heat.scaling.template.resource_templates. """ instance_definition = self._get_instance_definition() old_resources = self._get_instance_templates() templates = template.resource_templates( old_resources, instance_definition, num_instances, num_replace) return {"Resources": dict(templates)} def _replace(self, min_in_service, batch_size, pause_time): """ Replace the instances in the group using updated launch configuration """ def changing_instances(tmpl): instances = self.get_instances() serialize_template = functools.partial(json.dumps, sort_keys=True) current = set((i.name, serialize_template(i.t)) for i in instances) updated = set((k, serialize_template(v)) for k, v in tmpl['Resources'].items()) # includes instances to be updated and deleted affected = set(k for k, v in current ^ updated) return set(i.FnGetRefId() for i in instances if i.name in affected) def pause_between_batch(): while True: try: yield except scheduler.Timeout: return capacity = len(self.nested()) if self.nested() else 0 efft_bat_sz = min(batch_size, capacity) efft_min_sz = min(min_in_service, capacity) pause_sec = iso8601utils.parse_isoduration(pause_time) batch_cnt = (capacity + efft_bat_sz - 1) // efft_bat_sz if pause_sec * (batch_cnt - 1) >= self.stack.timeout_secs(): raise ValueError('The current UpdatePolicy will result ' 'in stack update timeout.') # effective capacity includes temporary capacity added to accommodate # the minimum number of instances in service during update efft_capacity = max(capacity - efft_bat_sz, efft_min_sz) + efft_bat_sz try: remainder = capacity while remainder > 0 or efft_capacity > capacity: if capacity - remainder >= efft_min_sz: efft_capacity = capacity template = self._create_template(efft_capacity, efft_bat_sz) self._lb_reload(exclude=changing_instances(template)) updater = self.update_with_template(template, self._environment()) updater.run_to_completion() self.check_update_complete(updater) remainder -= efft_bat_sz if remainder > 0 and pause_sec > 0: self._lb_reload() waiter = scheduler.TaskRunner(pause_between_batch) waiter(timeout=pause_sec) finally: self._lb_reload() def resize(self, new_capacity): """ Resize the instance group to the new capacity. When shrinking, the oldest instances will be removed. """ new_template = self._create_template(new_capacity) try: updater = self.update_with_template(new_template, self._environment()) updater.run_to_completion() self.check_update_complete(updater) finally: # Reload the LB in any case, so it's only pointing at healthy # nodes. self._lb_reload() def _lb_reload(self, exclude=[]): ''' Notify the LoadBalancer to reload its config to include the changes in instances we have just made. This must be done after activation (instance in ACTIVE state), otherwise the instances' IP addresses may not be available. ''' if self.properties[self.LOAD_BALANCER_NAMES]: id_list = [inst.FnGetRefId() for inst in self.get_instances() if inst.FnGetRefId() not in exclude] for lb in self.properties[self.LOAD_BALANCER_NAMES]: lb_resource = self.stack[lb] if 'Instances' in lb_resource.properties_schema: lb_resource.json_snippet['Properties']['Instances'] = ( id_list) elif 'members' in lb_resource.properties_schema: lb_resource.json_snippet['Properties']['members'] = ( id_list) else: raise exception.Error( _("Unsupported resource '%s' in LoadBalancerNames") % (lb,)) resolved_snippet = self.stack.resolve_static_data( lb_resource.json_snippet) scheduler.TaskRunner(lb_resource.update, resolved_snippet)() def FnGetRefId(self): return self.physical_resource_name() def _resolve_attribute(self, name): ''' heat extension: "InstanceList" returns comma delimited list of server ip addresses. ''' if name == 'InstanceList': return u','.join(inst.FnGetAtt('PublicIp') for inst in self.get_instances()) or None def child_template(self): num_instances = int(self.properties[self.SIZE]) return self._create_template(num_instances) def child_params(self): return self._environment() class AutoScalingGroup(InstanceGroup, CooldownMixin): PROPERTIES = ( AVAILABILITY_ZONES, LAUNCH_CONFIGURATION_NAME, MAX_SIZE, MIN_SIZE, COOLDOWN, DESIRED_CAPACITY, HEALTH_CHECK_GRACE_PERIOD, HEALTH_CHECK_TYPE, LOAD_BALANCER_NAMES, VPCZONE_IDENTIFIER, TAGS, ) = ( 'AvailabilityZones', 'LaunchConfigurationName', 'MaxSize', 'MinSize', 'Cooldown', 'DesiredCapacity', 'HealthCheckGracePeriod', 'HealthCheckType', 'LoadBalancerNames', 'VPCZoneIdentifier', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) _UPDATE_POLICY_SCHEMA_KEYS = ( ROLLING_UPDATE ) = ( 'AutoScalingRollingUpdate' ) _ROLLING_UPDATE_SCHEMA_KEYS = ( MIN_INSTANCES_IN_SERVICE, MAX_BATCH_SIZE, PAUSE_TIME ) = ( 'MinInstancesInService', 'MaxBatchSize', 'PauseTime' ) properties_schema = { AVAILABILITY_ZONES: properties.Schema( properties.Schema.LIST, _('Not Implemented.'), required=True ), LAUNCH_CONFIGURATION_NAME: properties.Schema( properties.Schema.STRING, _('Name of LaunchConfiguration resource.'), required=True, update_allowed=True ), MAX_SIZE: properties.Schema( properties.Schema.INTEGER, _('Maximum number of instances in the group.'), required=True, update_allowed=True ), MIN_SIZE: properties.Schema( properties.Schema.INTEGER, _('Minimum number of instances in the group.'), required=True, update_allowed=True ), COOLDOWN: properties.Schema( properties.Schema.NUMBER, _('Cooldown period, in seconds.'), update_allowed=True ), DESIRED_CAPACITY: properties.Schema( properties.Schema.INTEGER, _('Desired initial number of instances.'), update_allowed=True ), HEALTH_CHECK_GRACE_PERIOD: properties.Schema( properties.Schema.INTEGER, _('Not Implemented.'), implemented=False ), HEALTH_CHECK_TYPE: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), constraints=[ constraints.AllowedValues(['EC2', 'ELB']), ], implemented=False ), LOAD_BALANCER_NAMES: properties.Schema( properties.Schema.LIST, _('List of LoadBalancer resources.') ), VPCZONE_IDENTIFIER: properties.Schema( properties.Schema.LIST, _('List of VPC subnet identifiers.') ), TAGS: properties.Schema( properties.Schema.LIST, _('Tags to attach to this group.'), schema=properties.Schema( properties.Schema.MAP, schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), } rolling_update_schema = { MIN_INSTANCES_IN_SERVICE: properties.Schema(properties.Schema.INTEGER, default=0), MAX_BATCH_SIZE: properties.Schema(properties.Schema.INTEGER, default=1), PAUSE_TIME: properties.Schema(properties.Schema.STRING, default='PT0S') } update_policy_schema = { ROLLING_UPDATE: properties.Schema( properties.Schema.MAP, schema=rolling_update_schema) } update_allowed_keys = ('Properties', 'UpdatePolicy') def handle_create(self): if self.properties[self.DESIRED_CAPACITY]: num_to_create = self.properties[self.DESIRED_CAPACITY] else: num_to_create = self.properties[self.MIN_SIZE] initial_template = self._create_template(num_to_create) return self.create_with_template(initial_template, self._environment()) def check_create_complete(self, task): """Invoke the cooldown after creation succeeds.""" done = super(AutoScalingGroup, self).check_create_complete(task) if done: self._cooldown_timestamp( "%s : %s" % (EXACT_CAPACITY, len(self.get_instances()))) return done def handle_update(self, json_snippet, tmpl_diff, prop_diff): """ If Properties has changed, update self.properties, so we get the new values during any subsequent adjustment. """ if tmpl_diff: # parse update policy if 'UpdatePolicy' in tmpl_diff: self.update_policy = Properties( self.update_policy_schema, json_snippet.get('UpdatePolicy', {}), parent_name=self.name, context=self.context) if prop_diff: self.properties = Properties(self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) # Replace instances first if launch configuration has changed if (self.update_policy[self.ROLLING_UPDATE] and self.LAUNCH_CONFIGURATION_NAME in prop_diff): policy = self.update_policy[self.ROLLING_UPDATE] self._replace(policy[self.MIN_INSTANCES_IN_SERVICE], policy[self.MAX_BATCH_SIZE], policy[self.PAUSE_TIME]) # Get the current capacity, we may need to adjust if # MinSize or MaxSize has changed capacity = len(self.get_instances()) # Figure out if an adjustment is required new_capacity = None if self.MIN_SIZE in prop_diff: if capacity < self.properties[self.MIN_SIZE]: new_capacity = self.properties[self.MIN_SIZE] if self.MAX_SIZE in prop_diff: if capacity > self.properties[self.MAX_SIZE]: new_capacity = self.properties[self.MAX_SIZE] if self.DESIRED_CAPACITY in prop_diff: if self.properties[self.DESIRED_CAPACITY]: new_capacity = self.properties[self.DESIRED_CAPACITY] if new_capacity is not None: self.adjust(new_capacity, adjustment_type=EXACT_CAPACITY) def adjust(self, adjustment, adjustment_type=CHANGE_IN_CAPACITY): """ Adjust the size of the scaling group if the cooldown permits. """ if self._cooldown_inprogress(): logger.info(_("%(name)s NOT performing scaling adjustment, " "cooldown %(cooldown)s") % { 'name': self.name, 'cooldown': self.properties[self.COOLDOWN]}) return capacity = len(self.get_instances()) if adjustment_type == CHANGE_IN_CAPACITY: new_capacity = capacity + adjustment elif adjustment_type == EXACT_CAPACITY: new_capacity = adjustment else: # PercentChangeInCapacity delta = capacity * adjustment / 100.0 if math.fabs(delta) < 1.0: rounded = int(math.ceil(delta) if delta > 0.0 else math.floor(delta)) else: rounded = int(math.floor(delta) if delta > 0.0 else math.ceil(delta)) new_capacity = capacity + rounded upper = self.properties[self.MAX_SIZE] lower = self.properties[self.MIN_SIZE] if new_capacity > upper: if upper > capacity: logger.info(_('truncating growth to %s') % upper) new_capacity = upper else: logger.warn(_('can not exceed %s') % upper) return if new_capacity < lower: if lower < capacity: logger.info(_('truncating shrinkage to %s') % lower) new_capacity = lower else: logger.warn(_('can not be less than %s') % lower) return if new_capacity == capacity: logger.debug(_('no change in capacity %d') % capacity) return # send a notification before, on-error and on-success. notif = { 'stack': self.stack, 'adjustment': adjustment, 'adjustment_type': adjustment_type, 'capacity': capacity, 'groupname': self.FnGetRefId(), 'message': _("Start resizing the group %(group)s") % { 'group': self.FnGetRefId()}, 'suffix': 'start', } notification.send(**notif) try: self.resize(new_capacity) except Exception as resize_ex: with excutils.save_and_reraise_exception(): try: notif.update({'suffix': 'error', 'message': str(resize_ex), }) notification.send(**notif) except Exception: logger.exception(_('Failed sending error notification')) else: notif.update({ 'suffix': 'end', 'capacity': new_capacity, 'message': _("End resizing the group %(group)s") % { 'group': notif['groupname']}, }) notification.send(**notif) self._cooldown_timestamp("%s : %s" % (adjustment_type, adjustment)) def _tags(self): """Add Identifing Tags to all servers in the group. This is so the Dimensions received from cfn-push-stats all include the groupname and stack id. Note: the group name must match what is returned from FnGetRefId """ autoscaling_tag = [{self.TAG_KEY: 'AutoScalingGroupName', self.TAG_VALUE: self.FnGetRefId()}] return super(AutoScalingGroup, self)._tags() + autoscaling_tag def validate(self): res = super(AutoScalingGroup, self).validate() if res: return res # check validity of group size min_size = self.properties[self.MIN_SIZE] max_size = self.properties[self.MAX_SIZE] if max_size < min_size: msg = _("MinSize can not be greater than MaxSize") raise exception.StackValidationFailed(message=msg) if min_size < 0: msg = _("The size of AutoScalingGroup can not be less than zero") raise exception.StackValidationFailed(message=msg) if self.properties[self.DESIRED_CAPACITY]: desired_capacity = self.properties[self.DESIRED_CAPACITY] if desired_capacity < min_size or desired_capacity > max_size: msg = _("DesiredCapacity must be between MinSize and MaxSize") raise exception.StackValidationFailed(message=msg) # TODO(pasquier-s): once Neutron is able to assign subnets to # availability zones, it will be possible to specify multiple subnets. # For now, only one subnet can be specified. The bug #1096017 tracks # this issue. if self.properties.get(self.VPCZONE_IDENTIFIER) and \ len(self.properties[self.VPCZONE_IDENTIFIER]) != 1: raise exception.NotSupported(feature=_("Anything other than one " "VPCZoneIdentifier")) class LaunchConfiguration(resource.Resource): PROPERTIES = ( IMAGE_ID, INSTANCE_TYPE, KEY_NAME, USER_DATA, SECURITY_GROUPS, KERNEL_ID, RAM_DISK_ID, BLOCK_DEVICE_MAPPINGS, NOVA_SCHEDULER_HINTS, ) = ( 'ImageId', 'InstanceType', 'KeyName', 'UserData', 'SecurityGroups', 'KernelId', 'RamDiskId', 'BlockDeviceMappings', 'NovaSchedulerHints', ) _NOVA_SCHEDULER_HINT_KEYS = ( NOVA_SCHEDULER_HINT_KEY, NOVA_SCHEDULER_HINT_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { IMAGE_ID: properties.Schema( properties.Schema.STRING, _('Glance image ID or name.'), required=True ), INSTANCE_TYPE: properties.Schema( properties.Schema.STRING, _('Nova instance type (flavor).'), required=True ), KEY_NAME: properties.Schema( properties.Schema.STRING, _('Optional Nova keypair name.') ), USER_DATA: properties.Schema( properties.Schema.STRING, _('User data to pass to instance.') ), SECURITY_GROUPS: properties.Schema( properties.Schema.LIST, _('Security group names to assign.') ), KERNEL_ID: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), RAM_DISK_ID: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), BLOCK_DEVICE_MAPPINGS: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), NOVA_SCHEDULER_HINTS: properties.Schema( properties.Schema.LIST, _('Scheduler hints to pass to Nova (Heat extension).'), schema=properties.Schema( properties.Schema.MAP, schema={ NOVA_SCHEDULER_HINT_KEY: properties.Schema( properties.Schema.STRING, required=True ), NOVA_SCHEDULER_HINT_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), } def FnGetRefId(self): return unicode(self.physical_resource_name()) class AutoScalingResourceGroup(AutoScalingGroup): """An autoscaling group that can scale arbitrary resources.""" PROPERTIES = ( RESOURCE, MAX_SIZE, MIN_SIZE, COOLDOWN, DESIRED_CAPACITY ) = ( 'resource', 'max_size', 'min_size', 'cooldown', 'desired_capacity' ) properties_schema = { RESOURCE: properties.Schema( properties.Schema.MAP, _('Resource definition for the resources in the group, in HOT ' 'format. The value of this property is the definition of a ' 'resource just as if it had been declared in the template ' 'itself.'), required=True ), MAX_SIZE: properties.Schema( properties.Schema.INTEGER, _('Maximum number of resources in the group.'), required=True, update_allowed=True, constraints=[constraints.Range(min=0)], ), MIN_SIZE: properties.Schema( properties.Schema.INTEGER, _('Minimum number of resources in the group.'), required=True, update_allowed=True, constraints=[constraints.Range(min=0)] ), COOLDOWN: properties.Schema( properties.Schema.INTEGER, _('Cooldown period, in seconds.'), update_allowed=True ), DESIRED_CAPACITY: properties.Schema( properties.Schema.INTEGER, _('Desired initial number of resources.'), update_allowed=True ), } update_allowed_keys = ('Properties',) # Override the InstanceGroup attributes_schema; we don't want any # attributes. attributes_schema = {} def _get_instance_definition(self): resource_definition = self.properties[self.RESOURCE] # resolve references within the context of this stack. return self.stack.resolve_runtime_data(resource_definition) def _lb_reload(self, exclude=None): """AutoScalingResourceGroup does not maintain load balancer connections, so we just ignore calls to update the LB. """ pass def _get_instance_templates(self): """ Get templates for resource instances in HOT format. AutoScalingResourceGroup uses HOT as template format for scaled resources. Templates for existing resources use CFN syntax and have to be converted to HOT since those templates get used for generating scaled resource templates. """ CFN_TO_HOT_ATTRS = {'Type': 'type', 'Properties': 'properties', 'Metadata': 'metadata', 'DependsOn': 'depends_on', 'DeletionPolicy': 'deletion_policy', 'UpdatePolicy': 'update_policy'} def to_hot(template): hot_template = {} for attr, attr_value in template.iteritems(): hot_attr = CFN_TO_HOT_ATTRS.get(attr, attr) hot_template[hot_attr] = attr_value return hot_template return [(instance.name, to_hot(instance.t)) for instance in self.get_instances()] def _create_template(self, *args, **kwargs): """Use a HOT format for the template in the nested stack.""" tpl = super(AutoScalingResourceGroup, self)._create_template( *args, **kwargs) tpl['heat_template_version'] = '2013-05-23' tpl['resources'] = tpl.pop('Resources') return tpl class ScalingPolicy(signal_responder.SignalResponder, CooldownMixin): PROPERTIES = ( AUTO_SCALING_GROUP_NAME, SCALING_ADJUSTMENT, ADJUSTMENT_TYPE, COOLDOWN, ) = ( 'AutoScalingGroupName', 'ScalingAdjustment', 'AdjustmentType', 'Cooldown', ) EXACT_CAPACITY, CHANGE_IN_CAPACITY, PERCENT_CHANGE_IN_CAPACITY = ( 'ExactCapacity', 'ChangeInCapacity', 'PercentChangeInCapacity') properties_schema = { AUTO_SCALING_GROUP_NAME: properties.Schema( properties.Schema.STRING, _('AutoScaling group name to apply policy to.'), required=True ), SCALING_ADJUSTMENT: properties.Schema( properties.Schema.NUMBER, _('Size of adjustment.'), required=True, update_allowed=True ), ADJUSTMENT_TYPE: properties.Schema( properties.Schema.STRING, _('Type of adjustment (absolute or percentage).'), required=True, constraints=[ constraints.AllowedValues([CHANGE_IN_CAPACITY, EXACT_CAPACITY, PERCENT_CHANGE_IN_CAPACITY]), ], update_allowed=True ), COOLDOWN: properties.Schema( properties.Schema.NUMBER, _('Cooldown period, in seconds.'), update_allowed=True ), } update_allowed_keys = ('Properties',) attributes_schema = { "AlarmUrl": _("A signed url to handle the alarm. " "(Heat extension).") } def handle_create(self): super(ScalingPolicy, self).handle_create() self.resource_id_set(self._get_user_id()) def handle_update(self, json_snippet, tmpl_diff, prop_diff): """ If Properties has changed, update self.properties, so we get the new values during any subsequent adjustment. """ if prop_diff: self.properties = Properties(self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) def _get_adjustement_type(self): return self.properties[self.ADJUSTMENT_TYPE] def handle_signal(self, details=None): if self.action in (self.SUSPEND, self.DELETE): msg = _('Cannot signal resource during %s') % self.action raise Exception(msg) # ceilometer sends details like this: # {u'alarm_id': ID, u'previous': u'ok', u'current': u'alarm', # u'reason': u'...'}) # in this policy we currently assume that this gets called # only when there is an alarm. But the template writer can # put the policy in all the alarm notifiers (nodata, and ok). # # our watchrule has upper case states so lower() them all. if details is None: alarm_state = 'alarm' else: alarm_state = details.get('current', details.get('state', 'alarm')).lower() logger.info(_('%(name)s Alarm, new state %(state)s') % { 'name': self.name, 'state': alarm_state}) if alarm_state != 'alarm': return if self._cooldown_inprogress(): logger.info(_("%(name)s NOT performing scaling action, " "cooldown %(cooldown)s") % { 'name': self.name, 'cooldown': self.properties[self.COOLDOWN]}) return asgn_id = self.properties[self.AUTO_SCALING_GROUP_NAME] group = self.stack.resource_by_refid(asgn_id) if group is None: raise exception.NotFound(_('Alarm %(alarm)s could not find ' 'scaling group named "%(group)s"') % { 'alarm': self.name, 'group': asgn_id}) logger.info(_('%(name)s Alarm, adjusting Group %(group)s with id ' '%(asgn_id)s by %(filter)s') % { 'name': self.name, 'group': group.name, 'asgn_id': asgn_id, 'filter': self.properties[self.SCALING_ADJUSTMENT]}) adjustment_type = self._get_adjustement_type() group.adjust(self.properties[self.SCALING_ADJUSTMENT], adjustment_type) self._cooldown_timestamp("%s : %s" % (self.properties[self.ADJUSTMENT_TYPE], self.properties[self.SCALING_ADJUSTMENT])) def _resolve_attribute(self, name): ''' heat extension: "AlarmUrl" returns the url to post to the policy when there is an alarm. ''' if name == 'AlarmUrl' and self.resource_id is not None: return unicode(self._get_signed_url()) def FnGetRefId(self): if self.resource_id is not None: return unicode(self._get_signed_url()) else: return unicode(self.name) class AutoScalingPolicy(ScalingPolicy): """A resource to manage scaling of `OS::Heat::AutoScalingGroup`. **Note** while it may incidentally support `AWS::AutoScaling::AutoScalingGroup` for now, please don't use it for that purpose and use `AWS::AutoScaling::ScalingPolicy` instead. """ PROPERTIES = ( AUTO_SCALING_GROUP_NAME, SCALING_ADJUSTMENT, ADJUSTMENT_TYPE, COOLDOWN, ) = ( 'auto_scaling_group_id', 'scaling_adjustment', 'adjustment_type', 'cooldown', ) EXACT_CAPACITY, CHANGE_IN_CAPACITY, PERCENT_CHANGE_IN_CAPACITY = ( 'exact_capacity', 'change_in_capacity', 'percent_change_in_capacity') properties_schema = { AUTO_SCALING_GROUP_NAME: properties.Schema( properties.Schema.STRING, _('AutoScaling group ID to apply policy to.'), required=True ), SCALING_ADJUSTMENT: properties.Schema( properties.Schema.NUMBER, _('Size of adjustment.'), required=True, update_allowed=True ), ADJUSTMENT_TYPE: properties.Schema( properties.Schema.STRING, _('Type of adjustment (absolute or percentage).'), required=True, constraints=[ constraints.AllowedValues([CHANGE_IN_CAPACITY, EXACT_CAPACITY, PERCENT_CHANGE_IN_CAPACITY]), ], update_allowed=True ), COOLDOWN: properties.Schema( properties.Schema.NUMBER, _('Cooldown period, in seconds.'), update_allowed=True ), } update_allowed_keys = ('Properties',) attributes_schema = { "alarm_url": _("A signed url to handle the alarm.") } def _get_adjustement_type(self): adjustment_type = self.properties[self.ADJUSTMENT_TYPE] return ''.join([t.capitalize() for t in adjustment_type.split('_')]) def _resolve_attribute(self, name): if name == 'alarm_url' and self.resource_id is not None: return unicode(self._get_signed_url()) def FnGetRefId(self): return resource.Resource.FnGetRefId(self) def resource_mapping(): return { 'AWS::AutoScaling::LaunchConfiguration': LaunchConfiguration, 'AWS::AutoScaling::AutoScalingGroup': AutoScalingGroup, 'AWS::AutoScaling::ScalingPolicy': ScalingPolicy, 'OS::Heat::InstanceGroup': InstanceGroup, 'OS::Heat::AutoScalingGroup': AutoScalingResourceGroup, 'OS::Heat::ScalingPolicy': AutoScalingPolicy, } heat-2014.1.5/heat/engine/resources/volume.py0000664000567000056700000005001312540642614022111 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. import json from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources import nova_utils from heat.engine import scheduler from heat.engine import support from heat.openstack.common.importutils import try_import from heat.openstack.common import log as logging volume_backups = try_import('cinderclient.v1.volume_backups') logger = logging.getLogger(__name__) class Volume(resource.Resource): PROPERTIES = ( AVAILABILITY_ZONE, SIZE, BACKUP_ID, TAGS, ) = ( 'AvailabilityZone', 'Size', 'SnapshotId', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { AVAILABILITY_ZONE: properties.Schema( properties.Schema.STRING, _('The availability zone in which the volume will be created.'), required=True ), SIZE: properties.Schema( properties.Schema.NUMBER, _('The size of the volume in GB.') ), BACKUP_ID: properties.Schema( properties.Schema.STRING, _('If specified, the backup used as the source to create the ' 'volume.') ), TAGS: properties.Schema( properties.Schema.LIST, _('The list of tags to associate with the volume.'), schema=properties.Schema( properties.Schema.MAP, schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), } _volume_creating_status = ['creating', 'restoring-backup'] def _display_name(self): return self.physical_resource_name() def _display_description(self): return self.physical_resource_name() def _create_arguments(self): if self.properties[self.TAGS]: tags = dict((tm[self.TAG_KEY], tm[self.TAG_VALUE]) for tm in self.properties[self.TAGS]) else: tags = None return { 'size': self.properties[self.SIZE], 'availability_zone': (self.properties[self.AVAILABILITY_ZONE] or None), 'metadata': tags } def handle_create(self): backup_id = self.properties.get(self.BACKUP_ID) cinder = self.cinder() if backup_id is not None: if volume_backups is None: raise exception.Error(_('Backups not supported.')) vol_id = cinder.restores.restore(backup_id).volume_id vol = cinder.volumes.get(vol_id) vol.update( display_name=self._display_name(), display_description=self._display_description()) else: vol = cinder.volumes.create( display_name=self._display_name(), display_description=self._display_description(), **self._create_arguments()) self.resource_id_set(vol.id) return vol def check_create_complete(self, vol): vol.get() if vol.status == 'available': return True elif vol.status in self._volume_creating_status: return False else: raise exception.Error(vol.status) def _backup(self): backup = self.cinder().backups.create(self.resource_id) while backup.status == 'creating': yield backup.get() if backup.status != 'available': raise exception.Error(backup.status) @scheduler.wrappertask def _delete(self, backup=False): if self.resource_id is not None: try: vol = self.cinder().volumes.get(self.resource_id) if backup: yield self._backup() vol.get() if vol.status == 'in-use': logger.warn(_('can not delete volume when in-use')) raise exception.Error(_('Volume in use')) vol.delete() while True: yield vol.get() except clients.cinderclient.exceptions.NotFound: self.resource_id_set(None) if volume_backups is not None: def handle_snapshot_delete(self, state): backup = state not in ((self.CREATE, self.FAILED), (self.UPDATE, self.FAILED)) delete_task = scheduler.TaskRunner(self._delete, backup=backup) delete_task.start() return delete_task def handle_delete(self): delete_task = scheduler.TaskRunner(self._delete) delete_task.start() return delete_task def check_delete_complete(self, delete_task): return delete_task.step() class VolumeAttachTask(object): """A task for attaching a volume to a Nova server.""" def __init__(self, stack, server_id, volume_id, device): """ Initialise with the stack (for obtaining the clients), ID of the server and volume, and the device name on the server. """ self.clients = stack.clients self.server_id = server_id self.volume_id = volume_id self.device = device self.attachment_id = None def __str__(self): """Return a human-readable string description of the task.""" return 'Attaching Volume %s to Instance %s as %s' % (self.volume_id, self.server_id, self.device) def __repr__(self): """Return a brief string description of the task.""" return '%s(%s -> %s [%s])' % (type(self).__name__, self.volume_id, self.server_id, self.device) def __call__(self): """Return a co-routine which runs the task.""" logger.debug(str(self)) va = self.clients.nova().volumes.create_server_volume( server_id=self.server_id, volume_id=self.volume_id, device=self.device) self.attachment_id = va.id yield vol = self.clients.cinder().volumes.get(self.volume_id) while vol.status == 'available' or vol.status == 'attaching': logger.debug(_('%(name)s - volume status: %(status)s') % { 'name': str(self), 'status': vol.status}) yield vol.get() if vol.status != 'in-use': raise exception.Error(vol.status) logger.info(_('%s - complete') % str(self)) class VolumeDetachTask(object): """A task for detaching a volume from a Nova server.""" def __init__(self, stack, server_id, attachment_id): """ Initialise with the stack (for obtaining the clients), and the IDs of the server and volume. """ self.clients = stack.clients self.server_id = server_id self.attachment_id = attachment_id def __str__(self): """Return a human-readable string description of the task.""" return _('Removing attachment %(att)s from Instance %(srv)s') % { 'att': self.attachment_id, 'srv': self.server_id} def __repr__(self): """Return a brief string description of the task.""" return '%s(%s -/> %s)' % (type(self).__name__, self.attachment_id, self.server_id) def __call__(self): """Return a co-routine which runs the task.""" logger.debug(str(self)) server_api = self.clients.nova().volumes # get reference to the volume while it is attached try: nova_vol = server_api.get_server_volume(self.server_id, self.attachment_id) vol = self.clients.cinder().volumes.get(nova_vol.id) except (clients.cinderclient.exceptions.NotFound, clients.novaclient.exceptions.BadRequest, clients.novaclient.exceptions.NotFound): logger.warning(_('%s - volume not found') % str(self)) return # detach the volume using volume_attachment try: server_api.delete_server_volume(self.server_id, self.attachment_id) except (clients.novaclient.exceptions.BadRequest, clients.novaclient.exceptions.NotFound) as e: logger.warning('%(res)s - %(err)s' % {'res': str(self), 'err': str(e)}) yield try: while vol.status in ('in-use', 'detaching'): logger.debug(_('%s - volume still in use') % str(self)) yield vol.get() logger.info(_('%(name)s - status: %(status)s') % { 'name': str(self), 'status': vol.status}) if vol.status != 'available': raise exception.Error(vol.status) except clients.cinderclient.exceptions.NotFound: logger.warning(_('%s - volume not found') % str(self)) # The next check is needed for immediate reattachment when updating: # as the volume info is taken from cinder, but the detach # request is sent to nova, there might be some time # between cinder marking volume as 'available' and # nova removing attachment from it's own objects, so we # check that nova already knows that the volume is detached def server_has_attachment(server_id, attachment_id): try: server_api.get_server_volume(server_id, attachment_id) except clients.novaclient.exceptions.NotFound: return False return True while server_has_attachment(self.server_id, self.attachment_id): logger.info(_("Server %(srv)s still has attachment %(att)s.") % {'att': self.attachment_id, 'srv': self.server_id}) yield logger.info(_("Volume %(vol)s is detached from server %(srv)s") % {'vol': vol.id, 'srv': self.server_id}) class VolumeAttachment(resource.Resource): PROPERTIES = ( INSTANCE_ID, VOLUME_ID, DEVICE, ) = ( 'InstanceId', 'VolumeId', 'Device', ) properties_schema = { INSTANCE_ID: properties.Schema( properties.Schema.STRING, _('The ID of the instance to which the volume attaches.'), required=True, update_allowed=True ), VOLUME_ID: properties.Schema( properties.Schema.STRING, _('The ID of the volume to be attached.'), required=True, update_allowed=True ), DEVICE: properties.Schema( properties.Schema.STRING, _('The device where the volume is exposed on the instance. This ' 'assignment may not be honored and it is advised that the path ' '/dev/disk/by-id/virtio- be used instead.'), required=True, update_allowed=True, constraints=[ constraints.AllowedPattern('/dev/vd[b-z]'), ] ), } update_allowed_keys = ('Properties',) def handle_create(self): server_id = self.properties[self.INSTANCE_ID] volume_id = self.properties[self.VOLUME_ID] dev = self.properties[self.DEVICE] attach_task = VolumeAttachTask(self.stack, server_id, volume_id, dev) attach_runner = scheduler.TaskRunner(attach_task) attach_runner.start() self.resource_id_set(attach_task.attachment_id) return attach_runner def check_create_complete(self, attach_runner): return attach_runner.step() def handle_delete(self): server_id = self.properties[self.INSTANCE_ID] detach_task = VolumeDetachTask(self.stack, server_id, self.resource_id) scheduler.TaskRunner(detach_task)() def handle_update(self, json_snippet, tmpl_diff, prop_diff): checkers = [] if prop_diff: # Even though some combinations of changed properties # could be updated in UpdateReplace manner, # we still first detach the old resource so that # self.resource_id is not replaced prematurely volume_id = self.properties.get(self.VOLUME_ID) if self.VOLUME_ID in prop_diff: volume_id = prop_diff.get(self.VOLUME_ID) device = self.properties.get(self.DEVICE) if self.DEVICE in prop_diff: device = prop_diff.get(self.DEVICE) server_id = self.properties.get(self.INSTANCE_ID) detach_task = VolumeDetachTask(self.stack, server_id, self.resource_id) checkers.append(scheduler.TaskRunner(detach_task)) if self.INSTANCE_ID in prop_diff: server_id = prop_diff.get(self.INSTANCE_ID) attach_task = VolumeAttachTask(self.stack, server_id, volume_id, device) checkers.append(scheduler.TaskRunner(attach_task)) if checkers: checkers[0].start() return checkers def check_update_complete(self, checkers): for checker in checkers: if not checker.started(): checker.start() if not checker.step(): return False self.resource_id_set(checkers[-1]._task.attachment_id) return True class CinderVolume(Volume): PROPERTIES = ( AVAILABILITY_ZONE, SIZE, SNAPSHOT_ID, BACKUP_ID, NAME, DESCRIPTION, VOLUME_TYPE, METADATA, IMAGE_REF, IMAGE, SOURCE_VOLID, ) = ( 'availability_zone', 'size', 'snapshot_id', 'backup_id', 'name', 'description', 'volume_type', 'metadata', 'imageRef', 'image', 'source_volid', ) properties_schema = { AVAILABILITY_ZONE: properties.Schema( properties.Schema.STRING, _('The availability zone in which the volume will be created.') ), SIZE: properties.Schema( properties.Schema.NUMBER, _('The size of the volume in GB.'), constraints=[ constraints.Range(min=1), ] ), SNAPSHOT_ID: properties.Schema( properties.Schema.STRING, _('If specified, the snapshot to create the volume from.') ), BACKUP_ID: properties.Schema( properties.Schema.STRING, _('If specified, the backup to create the volume from.') ), NAME: properties.Schema( properties.Schema.STRING, _('A name used to distinguish the volume.') ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('A description of the volume.') ), VOLUME_TYPE: properties.Schema( properties.Schema.STRING, _('If specified, the type of volume to use, mapping to a ' 'specific backend.') ), METADATA: properties.Schema( properties.Schema.MAP, _('Key/value pairs to associate with the volume.') ), IMAGE_REF: properties.Schema( properties.Schema.STRING, _('The ID of the image to create the volume from.'), support_status=support.SupportStatus( support.DEPRECATED, _('Use property %s.') % IMAGE) ), IMAGE: properties.Schema( properties.Schema.STRING, _('If specified, the name or ID of the image to create the ' 'volume from.'), constraints=[ constraints.CustomConstraint('glance.image') ] ), SOURCE_VOLID: properties.Schema( properties.Schema.STRING, _('If specified, the volume to use as source.') ), } attributes_schema = { 'availability_zone': _('The availability zone in which the volume is ' ' located.'), 'size': _('The size of the volume in GB.'), 'snapshot_id': _('The snapshot the volume was created from, if any.'), 'display_name': _('Name of the volume.'), 'display_description': _('Description of the volume.'), 'volume_type': _('The type of the volume mapping to a backend, if ' 'any.'), 'metadata': _('Key/value pairs associated with the volume.'), 'source_volid': _('The volume used as source, if any.'), 'status': _('The current status of the volume.'), 'created_at': _('The timestamp indicating volume creation.'), 'bootable': _('Boolean indicating if the volume can be booted or ' 'not.'), } _volume_creating_status = ['creating', 'restoring-backup', 'downloading'] def _display_name(self): name = self.properties[self.NAME] if name: return name return super(CinderVolume, self)._display_name() def _display_description(self): return self.properties[self.DESCRIPTION] def _create_arguments(self): arguments = { 'size': self.properties[self.SIZE], 'availability_zone': self.properties[self.AVAILABILITY_ZONE] } if self.properties.get(self.IMAGE): arguments['imageRef'] = nova_utils.get_image_id( self.nova(), self.properties[self.IMAGE]) elif self.properties.get(self.IMAGE_REF): arguments['imageRef'] = self.properties[self.IMAGE_REF] optionals = (self.SNAPSHOT_ID, self.VOLUME_TYPE, self.SOURCE_VOLID, self.METADATA) arguments.update((prop, self.properties[prop]) for prop in optionals if self.properties[prop]) return arguments def _resolve_attribute(self, name): vol = self.cinder().volumes.get(self.resource_id) if name == 'metadata': return unicode(json.dumps(vol.metadata)) return unicode(getattr(vol, name)) class CinderVolumeAttachment(VolumeAttachment): PROPERTIES = ( INSTANCE_ID, VOLUME_ID, DEVICE, ) = ( 'instance_uuid', 'volume_id', 'mountpoint', ) properties_schema = { INSTANCE_ID: properties.Schema( properties.Schema.STRING, _('The ID of the server to which the volume attaches.'), required=True, update_allowed=True ), VOLUME_ID: properties.Schema( properties.Schema.STRING, _('The ID of the volume to be attached.'), required=True, update_allowed=True ), DEVICE: properties.Schema( properties.Schema.STRING, _('The location where the volume is exposed on the instance. This ' 'assignment may not be honored and it is advised that the path ' '/dev/disk/by-id/virtio- be used instead.'), update_allowed=True ), } def resource_mapping(): return { 'AWS::EC2::Volume': Volume, 'AWS::EC2::VolumeAttachment': VolumeAttachment, 'OS::Cinder::Volume': CinderVolume, 'OS::Cinder::VolumeAttachment': CinderVolumeAttachment, } heat-2014.1.5/heat/engine/resources/template_resource.py0000664000567000056700000002514212540642614024331 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. import hashlib import json from requests import exceptions from heat.common import exception from heat.common import template_format from heat.common import urlfetch from heat.engine import attributes from heat.engine import environment from heat.engine import properties from heat.engine import stack_resource from heat.engine import template from heat.openstack.common import log as logging logger = logging.getLogger(__name__) def generate_class(name, template_name): try: data = urlfetch.get(template_name, allowed_schemes=('file',)) except IOError: return TemplateResource tmpl = template.Template(template_format.parse(data)) properties_schema = properties.Properties.schema_from_params( tmpl.param_schemata()) attributes_schema = attributes.Attributes.schema_from_outputs( tmpl[tmpl.OUTPUTS]) cls = type(name, (TemplateResource,), {"properties_schema": properties_schema, "attributes_schema": attributes_schema}) return cls class TemplateResource(stack_resource.StackResource): ''' A resource implemented by a nested stack. This implementation passes resource properties as parameters to the nested stack. Outputs of the nested stack are exposed as attributes of this resource. ''' def __init__(self, name, json_snippet, stack): self._parsed_nested = None self.stack = stack self.validation_exception = None self.update_allowed_keys = ('Properties', 'Metadata') tri = stack.env.get_resource_info( json_snippet['Type'], registry_type=environment.TemplateResourceInfo) if tri is None: self.validation_exception = ValueError(_( 'Only Templates with an extension of .yaml or ' '.template are supported')) else: self.template_name = tri.template_name if tri.user_resource: self.allowed_schemes = ('http', 'https') else: self.allowed_schemes = ('http', 'https', 'file') # run Resource.__init__() so we can call self.nested() self.properties_schema = {} self.attributes_schema = {} super(TemplateResource, self).__init__(name, json_snippet, stack) if self.validation_exception is None: self._generate_schema(self.t.get('Properties', {})) def _generate_schema(self, props): self._parsed_nested = None try: tmpl = template.Template(self.child_template()) except ValueError as download_error: self.validation_exception = download_error tmpl = template.Template({}) # re-generate the properties and attributes from the template. self.properties_schema = (properties.Properties .schema_from_params(tmpl.param_schemata())) self.attributes_schema = (attributes.Attributes .schema_from_outputs(tmpl[tmpl.OUTPUTS])) self.properties = properties.Properties(self.properties_schema, props, self._resolve_runtime_data, self.name, self.context) self.attributes = attributes.Attributes(self.name, self.attributes_schema, self._resolve_attribute) def child_params(self): ''' :return: parameter values for our nested stack based on our properties ''' params = {} for pname, pval in iter(self.properties.props.items()): if not pval.implemented(): continue val = self.properties[pname] if val is not None: # take a list and create a CommaDelimitedList if pval.type() == properties.Schema.LIST: if len(val) == 0: params[pname] = '' elif isinstance(val[0], dict): flattened = [] for (count, item) in enumerate(val): for (ik, iv) in iter(item.items()): mem_str = '.member.%d.%s=%s' % (count, ik, iv) flattened.append(mem_str) params[pname] = ','.join(flattened) else: params[pname] = ','.join(val) else: # for MAP, the JSON param takes either a collection or # string, so just pass it on and let the param validate # as appropriate params[pname] = val return params def child_template(self): if not self._parsed_nested: self._parsed_nested = template_format.parse(self.template_data()) return self._parsed_nested def implementation_signature(self): self._generate_schema(self.t.get('Properties', {})) schema_names = ([prop for prop in self.properties_schema] + [at for at in self.attributes_schema]) schema_hash = hashlib.sha1(';'.join(schema_names)) templ_hash = hashlib.sha1(self.template_data()) return (schema_hash.hexdigest(), templ_hash.hexdigest()) def template_data(self): # we want to have the latest possible template. # 1. look in files # 2. try download # 3. look in the db reported_excp = None t_data = self.stack.t.files.get(self.template_name) if not t_data and self.template_name.endswith((".yaml", ".template")): try: t_data = urlfetch.get(self.template_name, allowed_schemes=self.allowed_schemes) except (exceptions.RequestException, IOError) as r_exc: reported_excp = ValueError(_("Could not fetch remote template " "'%(name)s': %(exc)s") % { 'name': self.template_name, 'exc': str(r_exc)}) if t_data is None: if self.nested() is not None: t_data = json.dumps(self.nested().t.t) if t_data is not None: self.stack.t.files[self.template_name] = t_data return t_data if reported_excp is None: reported_excp = ValueError(_('Unknown error retrieving %s') % self.template_name) raise reported_excp def _validate_against_facade(self, facade_cls): facade_schemata = properties.schemata(facade_cls.properties_schema) for n, fs in facade_schemata.items(): if fs.required and n not in self.properties_schema: msg = (_("Required property %(n)s for facade %(type)s " "missing in provider") % {'n': n, 'type': self.type()}) raise exception.StackValidationFailed(message=msg) ps = self.properties_schema.get(n) if (n in self.properties_schema and (fs.type != ps.type)): # Type mismatch msg = (_("Property %(n)s type mismatch between facade %(type)s" " (%(fs_type)s) and provider (%(ps_type)s)") % { 'n': n, 'type': self.type(), 'fs_type': fs.type, 'ps_type': ps.type}) raise exception.StackValidationFailed(message=msg) for n, ps in self.properties_schema.items(): if ps.required and n not in facade_schemata: # Required property for template not present in facade msg = (_("Provider requires property %(n)s " "unknown in facade %(type)s") % { 'n': n, 'type': self.type()}) raise exception.StackValidationFailed(message=msg) for attr in facade_cls.attributes_schema: if attr not in self.attributes_schema: msg = (_("Attribute %(attr)s for facade %(type)s " "missing in provider") % { 'attr': attr, 'type': self.type()}) raise exception.StackValidationFailed(message=msg) def validate(self): if self.validation_exception is not None: msg = str(self.validation_exception) raise exception.StackValidationFailed(message=msg) try: self.template_data() except ValueError as ex: msg = _("Failed to retrieve template data: %s") % str(ex) raise exception.StackValidationFailed(message=msg) cri = self.stack.env.get_resource_info( self.type(), registry_type=environment.ClassResourceInfo) # If we're using an existing resource type as a facade for this # template, check for compatibility between the interfaces. if cri is not None and not isinstance(self, cri.get_class()): facade_cls = cri.get_class() self._validate_against_facade(facade_cls) return super(TemplateResource, self).validate() def handle_adopt(self, resource_data=None): return self.create_with_template(self.parsed_nested(), self._to_parameters(), adopt_data=resource_data) def handle_create(self): return self.create_with_template(self.child_template(), self.child_params()) def handle_update(self, json_snippet, tmpl_diff, prop_diff): self._generate_schema(json_snippet.get('Properties', {})) return self.update_with_template(self.child_template(), self.child_params()) def handle_delete(self): return self.delete_nested() def FnGetRefId(self): if not self.nested(): return unicode(self.name) return self.nested().identifier().arn() heat-2014.1.5/heat/engine/resources/nova_keypair.py0000664000567000056700000001216312540642614023275 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. from novaclient import exceptions as nova_exceptions from heat.common import exception from heat.db import api as db_api from heat.engine.clients import Clients from heat.engine import properties from heat.engine import resource from heat.engine.resources import nova_utils from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class KeyPair(resource.Resource): """ A resource for creating Nova key pairs. **Note** that if a new key is generated setting `save_private_key` to `True` results in the system saving the private key which can then be retrieved via the `private_key` attribute of this resource. Setting the `public_key` property means that the `private_key` attribute of this resource will always return an empty string regardless of the `save_private_key` setting since there will be no private key data to save. """ PROPERTIES = ( NAME, SAVE_PRIVATE_KEY, PUBLIC_KEY, ) = ( 'name', 'save_private_key', 'public_key', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('The name of the key pair.'), required=True ), SAVE_PRIVATE_KEY: properties.Schema( properties.Schema.BOOLEAN, _('True if the system should remember a generated private key; ' 'False otherwise.'), default=False ), PUBLIC_KEY: properties.Schema( properties.Schema.STRING, _('The optional public key. This allows users to supply the ' 'public key from a pre-existing key pair. If not supplied, a ' 'new key pair will be generated.') ), } attributes_schema = { 'public_key': _('The public key.'), 'private_key': _('The private key if it has been saved.') } def __init__(self, name, json_snippet, stack): super(KeyPair, self).__init__(name, json_snippet, stack) self._private_key = None self._public_key = None @property def private_key(self): """Return the private SSH key for the resource.""" if (self._private_key is None and self.id and self.properties[self.SAVE_PRIVATE_KEY]): try: self._private_key = db_api.resource_data_get(self, 'private_key') except exception.NotFound: pass return self._private_key or "" @property def public_key(self): """Return the public SSH key for the resource.""" if not self._public_key: if self.properties[self.PUBLIC_KEY]: self._public_key = self.properties[self.PUBLIC_KEY] elif self.resource_id: nova_key = nova_utils.get_keypair(self.nova(), self.resource_id) self._public_key = nova_key.public_key return self._public_key def handle_create(self): pub_key = self.properties[self.PUBLIC_KEY] or None new_keypair = self.nova().keypairs.create(self.properties[self.NAME], public_key=pub_key) if (self.properties[self.SAVE_PRIVATE_KEY] and hasattr(new_keypair, 'private_key')): db_api.resource_data_set(self, 'private_key', new_keypair.private_key, True) self.resource_id_set(new_keypair.id) def handle_delete(self): if self.resource_id: try: self.nova().keypairs.delete(self.resource_id) except nova_exceptions.NotFound: pass def _resolve_attribute(self, key): attr_fn = {'private_key': self.private_key, 'public_key': self.public_key} return unicode(attr_fn[key]) def FnGetRefId(self): return self.resource_id class KeypairConstraint(object): def validate(self, value, context): if not value: # Don't validate empty key, which can happen when you use a KeyPair # resource return True try: nova_utils.get_keypair(Clients(context).nova(), value) except exception.UserKeyPairMissing: return False else: return True def constraint_mapping(): return {'nova.keypair': KeypairConstraint} def resource_mapping(): return {'OS::Nova::KeyPair': KeyPair} heat-2014.1.5/heat/engine/resources/software_config/0000775000567000056700000000000012540643116023406 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/software_config/cloud_config.py0000664000567000056700000000412512540642614026417 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. from heat.common.template_format import yaml from heat.common.template_format import yaml_dumper from heat.engine import properties from heat.engine.resources.software_config import software_config class CloudConfig(software_config.SoftwareConfig): ''' A configuration resource for representing cloud-init cloud-config. This resource allows cloud-config YAML to be defined and stored by the config API. Any intrinsic functions called in the config will be resolved before storing the result. This resource will generally be referenced by OS::Nova::Server user_data, or OS::Heat::MultipartMime parts config. Since cloud-config is boot-only configuration, any changes to the definition will result in the replacement of all servers which reference it. ''' PROPERTIES = ( CLOUD_CONFIG ) = ( 'cloud_config' ) properties_schema = { CLOUD_CONFIG: properties.Schema( properties.Schema.MAP, _('Map representing the cloud-config data structure which will ' 'be formatted as YAML.') ) } def handle_create(self): props = {self.NAME: self.physical_resource_name()} cloud_config = yaml.dump(self.properties.get( self.CLOUD_CONFIG), Dumper=yaml_dumper) props[self.CONFIG] = '#cloud-config\n%s' % cloud_config sc = self.heat().software_configs.create(**props) self.resource_id_set(sc.id) def resource_mapping(): return { 'OS::Heat::CloudConfig': CloudConfig, } heat-2014.1.5/heat/engine/resources/software_config/structured_config.py0000664000567000056700000001141212540642614027512 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # # 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. import collections import functools from heat.engine import properties from heat.engine.resources.software_config import software_config as sc from heat.engine.resources.software_config import software_deployment as sd PROPERTIES = ( INPUT_KEY ) = ( 'input_key' ) DEFAULT_INPUT_KEY = 'get_input' class StructuredConfig(sc.SoftwareConfig): ''' This resource is like OS::Heat::SoftwareConfig except that the config property is represented by a Map rather than a String. This is useful for configuration tools which use YAML or JSON as their configuration syntax. The resulting configuration is transferred, stored and returned by the software_configs API as parsed JSON. ''' properties_schema = { sc.SoftwareConfig.GROUP: sc.SoftwareConfig.properties_schema[ sc.SoftwareConfig.GROUP], sc.SoftwareConfig.OPTIONS: sc.SoftwareConfig.properties_schema[ sc.SoftwareConfig.OPTIONS], sc.SoftwareConfig.INPUTS: sc.SoftwareConfig.properties_schema[ sc.SoftwareConfig.INPUTS], sc.SoftwareConfig.OUTPUTS: sc.SoftwareConfig.properties_schema[ sc.SoftwareConfig.OUTPUTS], sc.SoftwareConfig.CONFIG: properties.Schema( properties.Schema.MAP, _('Map representing the configuration data structure which will ' 'be serialized to the chosen format.') ) } class StructuredDeployment(sd.SoftwareDeployment): ''' A deployment resource like OS::Heat::SoftwareDeployment, but which performs input value substitution on the config defined by a OS::Heat::StructuredConfig resource. Some configuration tools have no concept of inputs, so the input value substitution needs to occur in the deployment resource. An example of this is the JSON metadata consumed by the cfn-init tool. Where the config contains {get_input: input_name} this will be substituted with the value of input_name in this resource's input_values. If get_input needs to be passed through to the substituted configuration then a different input_key property value can be specified. ''' _sd_ps = sd.SoftwareDeployment.properties_schema properties_schema = { sd.SoftwareDeployment.CONFIG: _sd_ps[ sd.SoftwareDeployment.CONFIG], sd.SoftwareDeployment.SERVER: _sd_ps[ sd.SoftwareDeployment.SERVER], sd.SoftwareDeployment.INPUT_VALUES: _sd_ps[ sd.SoftwareDeployment.INPUT_VALUES], sd.SoftwareDeployment.DEPLOY_ACTIONS: _sd_ps[ sd.SoftwareDeployment.DEPLOY_ACTIONS], sd.SoftwareDeployment.SIGNAL_TRANSPORT: _sd_ps[ sd.SoftwareDeployment.SIGNAL_TRANSPORT], sd.SoftwareDeployment.NAME: _sd_ps[ sd.SoftwareDeployment.NAME], INPUT_KEY: properties.Schema( properties.Schema.STRING, _('Name of key to use for substituting inputs during deployment'), default=DEFAULT_INPUT_KEY, ) } def _build_derived_config(self, action, source, derived_inputs, derived_options): cfg = source.get(sc.SoftwareConfig.CONFIG) input_key = self.properties.get(INPUT_KEY) inputs = dict((i['name'], i['value']) for i in derived_inputs) return self.parse(inputs, input_key, cfg) @staticmethod def parse(inputs, input_key, snippet): parse = functools.partial( StructuredDeployment.parse, inputs, input_key) if isinstance(snippet, collections.Mapping): if len(snippet) == 1: fn_name, args = next(snippet.iteritems()) if fn_name == input_key: if isinstance(args, basestring): return inputs.get(args) return dict((k, parse(v)) for k, v in snippet.iteritems()) elif (not isinstance(snippet, basestring) and isinstance(snippet, collections.Iterable)): return [parse(v) for v in snippet] else: return snippet def resource_mapping(): return { 'OS::Heat::StructuredConfig': StructuredConfig, 'OS::Heat::StructuredDeployment': StructuredDeployment, } heat-2014.1.5/heat/engine/resources/software_config/software_deployment.py0000664000567000056700000004350612540642614030064 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # # 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. import copy import uuid import heatclient.exc as heat_exp from heat.common import exception from heat.db import api as db_api from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources.software_config import software_config as sc from heat.engine import signal_responder from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class SoftwareDeployment(signal_responder.SignalResponder): ''' This resource associates a server with some configuration which is to be deployed to that server. A deployment allows input values to be specified which map to the inputs schema defined in the config resource. These input values are interpreted by the configuration tool in a tool-specific manner. Whenever this resource goes to an IN_PROGRESS state, it creates an ephemeral config that includes the inputs values plus a number of extra inputs which have names prefixed with deploy_. The extra inputs relate to the current state of the stack, along with the information and credentials required to signal back the deployment results. Unless signal_transport=NO_SIGNAL, this resource will remain in an IN_PROGRESS state until the server signals it with the output values for that deployment. Those output values are then available as resource attributes, along with the default attributes deploy_stdout, deploy_stderr and deploy_status_code. Specifying actions other than the default CREATE and UPDATE will result in the deployment being triggered in those actions. For example this would allow cleanup configuration to be performed during actions SUSPEND and DELETE. A config could be designed to only work with some specific actions, or a config can read the value of the deploy_action input to allow conditional logic to perform different configuration for different actions. ''' PROPERTIES = ( CONFIG, SERVER, INPUT_VALUES, DEPLOY_ACTIONS, NAME, SIGNAL_TRANSPORT ) = ( 'config', 'server', 'input_values', 'actions', 'name', 'signal_transport' ) ALLOWED_DEPLOY_ACTIONS = ( resource.Resource.CREATE, resource.Resource.UPDATE, resource.Resource.DELETE, resource.Resource.SUSPEND, resource.Resource.RESUME, ) DEPLOY_ATTRIBUTES = ( STDOUT, STDERR, STATUS_CODE ) = ( 'deploy_stdout', 'deploy_stderr', 'deploy_status_code' ) DERIVED_CONFIG_INPUTS = ( DEPLOY_SERVER_ID, DEPLOY_ACTION, DEPLOY_SIGNAL_ID, DEPLOY_STACK_ID, DEPLOY_RESOURCE_NAME, DEPLOY_AUTH_URL, DEPLOY_USERNAME, DEPLOY_PASSWORD, DEPLOY_PROJECT_ID, DEPLOY_USER_ID ) = ( 'deploy_server_id', 'deploy_action', 'deploy_signal_id', 'deploy_stack_id', 'deploy_resource_name', 'deploy_auth_url', 'deploy_username', 'deploy_password', 'deploy_project_id', 'deploy_user_id' ) SIGNAL_TRANSPORTS = ( CFN_SIGNAL, HEAT_SIGNAL, NO_SIGNAL ) = ( 'CFN_SIGNAL', 'HEAT_SIGNAL', 'NO_SIGNAL' ) properties_schema = { CONFIG: properties.Schema( properties.Schema.STRING, _('ID of software configuration resource to execute when ' 'applying to the server.'), update_allowed=True ), SERVER: properties.Schema( properties.Schema.STRING, _('ID of Nova server to apply configuration to.'), ), INPUT_VALUES: properties.Schema( properties.Schema.MAP, _('Input values to apply to the software configuration on this ' 'server.'), update_allowed=True ), DEPLOY_ACTIONS: properties.Schema( properties.Schema.LIST, _('Which stack actions will result in this deployment being ' 'triggered.'), update_allowed=True, default=[resource.Resource.CREATE, resource.Resource.UPDATE], constraints=[constraints.AllowedValues(ALLOWED_DEPLOY_ACTIONS)] ), NAME: properties.Schema( properties.Schema.STRING, _('Name of the derived config associated with this deployment. ' 'This is used to apply a sort order to the list of ' 'configurations currently deployed to a server.'), ), SIGNAL_TRANSPORT: properties.Schema( properties.Schema.STRING, _('How the server should signal to heat with the deployment ' 'output values. CFN_SIGNAL will allow an HTTP POST to a CFN ' 'keypair signed URL. HEAT_SIGNAL will allow calls to ' 'the Heat API resource-signal using the provided keystone ' 'credentials. NO_SIGNAL will result in the resource going to ' 'the COMPLETE state without waiting for any signal.'), default=CFN_SIGNAL, constraints=[ constraints.AllowedValues(SIGNAL_TRANSPORTS), ] ), } attributes_schema = { STDOUT: _("Captured stdout from the configuration execution."), STDERR: _("Captured stderr from the configuration execution."), STATUS_CODE: _("Returned status code from the configuration " "execution"), } update_allowed_keys = ('Properties',) def _signal_transport_cfn(self): return self.properties.get( self.SIGNAL_TRANSPORT) == self.CFN_SIGNAL def _signal_transport_heat(self): return self.properties.get( self.SIGNAL_TRANSPORT) == self.HEAT_SIGNAL def _signal_transport_none(self): return self.properties.get( self.SIGNAL_TRANSPORT) == self.NO_SIGNAL def _build_properties(self, properties, config_id, action): props = { 'config_id': config_id, 'server_id': properties[SoftwareDeployment.SERVER], 'action': action, 'stack_user_project_id': self.stack.stack_user_project_id } if self._signal_transport_none(): props['status'] = SoftwareDeployment.COMPLETE props['status_reason'] = _('Not waiting for outputs signal') else: props['status'] = SoftwareDeployment.IN_PROGRESS props['status_reason'] = _('Deploy data available') return props def _delete_derived_config(self, derived_config_id): try: self.heat().software_configs.delete(derived_config_id) except heat_exp.HTTPNotFound: pass def _get_derived_config(self, action): source_config_id = self.properties.get(self.CONFIG) source_config = self.heat().software_configs.get(source_config_id) derived_params = self._build_derived_config_params( action, source_config.to_dict()) derived_config = self.heat().software_configs.create(**derived_params) return derived_config.id def _handle_action(self, action): if action not in self.properties[self.DEPLOY_ACTIONS]: return props = self._build_properties( self.properties, self._get_derived_config(action), action) if action == self.CREATE: sd = self.heat().software_deployments.create(**props) self.resource_id_set(sd.id) else: sd = self.heat().software_deployments.get(self.resource_id) previous_derived_config = sd.config_id sd.update(**props) if previous_derived_config: self._delete_derived_config(previous_derived_config) if not self._signal_transport_none(): return sd @staticmethod def _check_complete(sd): if not sd: return True # NOTE(dprince): when lazy loading the sd attributes # we need to support multiple versions of heatclient if hasattr(sd, 'get'): sd.get() else: sd._get() if sd.status == SoftwareDeployment.COMPLETE: return True elif sd.status == SoftwareDeployment.FAILED: message = _("Deployment to server " "failed: %s") % sd.status_reason logger.error(message) exc = exception.Error(message) raise exc def _build_derived_config_params(self, action, source): scl = sc.SoftwareConfig derived_inputs = self._build_derived_inputs(action, source) derived_options = self._build_derived_options(action, source) derived_config = self._build_derived_config( action, source, derived_inputs, derived_options) derived_name = self.properties.get(self.NAME) or source[scl.NAME] return { scl.GROUP: source[scl.GROUP], scl.CONFIG: derived_config, scl.OPTIONS: derived_options, scl.INPUTS: derived_inputs, scl.OUTPUTS: source.get(scl.OUTPUTS), scl.NAME: derived_name } def _build_derived_config(self, action, source, derived_inputs, derived_options): return source.get(sc.SoftwareConfig.CONFIG) def _build_derived_options(self, action, source): return source.get(sc.SoftwareConfig.OPTIONS) def _build_derived_inputs(self, action, source): scl = sc.SoftwareConfig inputs = copy.deepcopy(source.get(scl.INPUTS)) or [] input_values = dict(self.properties.get(self.INPUT_VALUES) or {}) for inp in inputs: input_key = inp[scl.NAME] inp['value'] = input_values.pop(input_key, inp[scl.DEFAULT]) # for any input values that do not have a declared input, add # a derived declared input so that they can be used as config # inputs for inpk, inpv in input_values.items(): inputs.append({ scl.NAME: inpk, scl.TYPE: 'String', 'value': inpv }) inputs.extend([{ scl.NAME: self.DEPLOY_SERVER_ID, scl.DESCRIPTION: _('ID of the server being deployed to'), scl.TYPE: 'String', 'value': self.properties.get(self.SERVER) }, { scl.NAME: self.DEPLOY_ACTION, scl.DESCRIPTION: _('Name of the current action being deployed'), scl.TYPE: 'String', 'value': action }, { scl.NAME: self.DEPLOY_STACK_ID, scl.DESCRIPTION: _('ID of the stack this deployment belongs to'), scl.TYPE: 'String', 'value': self.stack.identifier().stack_path() }, { scl.NAME: self.DEPLOY_RESOURCE_NAME, scl.DESCRIPTION: _('Name of this deployment resource in the ' 'stack'), scl.TYPE: 'String', 'value': self.name }]) if self._signal_transport_cfn(): inputs.append({ scl.NAME: self.DEPLOY_SIGNAL_ID, scl.DESCRIPTION: _('ID of signal to use for signalling ' 'output values'), scl.TYPE: 'String', 'value': self._get_signed_url() }) elif self._signal_transport_heat(): inputs.extend([{ scl.NAME: self.DEPLOY_AUTH_URL, scl.DESCRIPTION: _('URL for API authentication'), scl.TYPE: 'String', 'value': self.keystone().v3_endpoint }, { scl.NAME: self.DEPLOY_USERNAME, scl.DESCRIPTION: _('Username for API authentication'), scl.TYPE: 'String', 'value': self.physical_resource_name(), }, { scl.NAME: self.DEPLOY_USER_ID, scl.DESCRIPTION: _('User ID for API authentication'), scl.TYPE: 'String', 'value': self._get_user_id(), }, { scl.NAME: self.DEPLOY_PASSWORD, scl.DESCRIPTION: _('Password for API authentication'), scl.TYPE: 'String', 'value': self.password }, { scl.NAME: self.DEPLOY_PROJECT_ID, scl.DESCRIPTION: _('ID of project for API authentication'), scl.TYPE: 'String', 'value': self.stack.stack_user_project_id }]) return inputs def handle_create(self): if self._signal_transport_cfn(): self._create_user() self._create_keypair() if self._signal_transport_heat(): self.password = uuid.uuid4().hex self._create_user() return self._handle_action(self.CREATE) @property def password(self): try: return db_api.resource_data_get(self, 'password') except exception.NotFound: pass @password.setter def password(self, password): try: if password is None: db_api.resource_data_delete(self, 'password') else: db_api.resource_data_set(self, 'password', password, True) except exception.NotFound: pass def check_create_complete(self, sd): return self._check_complete(sd) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.properties = properties.Properties( self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) return self._handle_action(self.UPDATE) def check_update_complete(self, sd): return self._check_complete(sd) def handle_delete(self): if self.DELETE in self.properties[self.DEPLOY_ACTIONS]: return self._handle_action(self.DELETE) else: self._delete_resource() def check_delete_complete(self, sd=None): if not sd: return True if self._check_complete(sd): self._delete_resource() return True def _delete_resource(self): if self._signal_transport_cfn(): self._delete_signed_url() self._delete_user() elif self._signal_transport_heat(): self._delete_user() derived_config_id = None if self.resource_id is not None: try: sd = self.heat().software_deployments.get(self.resource_id) derived_config_id = sd.config_id sd.delete() except heat_exp.HTTPNotFound: pass if derived_config_id: self._delete_derived_config(derived_config_id) def handle_suspend(self): return self._handle_action(self.SUSPEND) def check_suspend_complete(self, sd): return self._check_complete(sd) def handle_resume(self): return self._handle_action(self.RESUME) def check_resume_complete(self, sd): return self._check_complete(sd) def handle_signal(self, details): sd = self.heat().software_deployments.get(self.resource_id) sc = self.heat().software_configs.get(self.properties[self.CONFIG]) if not sd.status == self.IN_PROGRESS: # output values are only expected when in an IN_PROGRESS state return details = details or {} ov = sd.output_values or {} status = None status_reasons = {} if details.get(self.STATUS_CODE): status = self.FAILED status_reasons[self.STATUS_CODE] = _( 'Deployment exited with non-zero status code: %s' ) % details.get(self.STATUS_CODE) for output in sc.outputs or []: out_key = output['name'] if out_key in details: ov[out_key] = details[out_key] if output.get('error_output', False): status = self.FAILED status_reasons[out_key] = details[out_key] for out_key in self.DEPLOY_ATTRIBUTES: ov[out_key] = details.get(out_key) if status == self.FAILED: # build a status reason out of all of the values of outputs # flagged as error_output status_reason = ', '.join([' : '.join((k, str(status_reasons[k]))) for k in status_reasons]) else: status = self.COMPLETE status_reason = _('Outputs received') sd.update(output_values=ov, status=status, status_reason=status_reason) def FnGetAtt(self, key): ''' Resource attributes map to deployment outputs values ''' sd = self.heat().software_deployments.get(self.resource_id) if key in sd.output_values: return sd.output_values.get(key) # Since there is no value for this key yet, check the output schemas # to find out if the key is valid sc = self.heat().software_configs.get(self.properties[self.CONFIG]) output_keys = [output['name'] for output in sc.outputs] if key not in output_keys and key not in self.DEPLOY_ATTRIBUTES: raise exception.InvalidTemplateAttribute(resource=self.name, key=key) def resource_mapping(): return { 'OS::Heat::SoftwareDeployment': SoftwareDeployment, } heat-2014.1.5/heat/engine/resources/software_config/__init__.py0000664000567000056700000000000012540642614025507 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/software_config/software_config.py0000664000567000056700000001542412540642614027147 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. import heatclient.exc as heat_exp from heat.common import exception from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class SoftwareConfig(resource.Resource): ''' A resource for describing and storing software configuration. The software_configs API which backs this resource creates immutable configs, so any change to the template resource definition will result in a new config being created, and the old one being deleted. Configs can be defined in the same template which uses them, or they can be created in one stack, and passed to another stack via a parameter. A config resource can be referenced in other resource properties which are config-aware. This includes the properties OS::Nova::Server user_data, OS::Heat::SoftwareDeployment config and OS::Heat::MultipartMime parts config. Along with the config script itself, this resource can define schemas for inputs and outputs which the config script is expected to consume and produce. Inputs and outputs are optional and will map to concepts which are specific to the configuration tool being used. ''' PROPERTIES = ( GROUP, CONFIG, OPTIONS, INPUTS, OUTPUTS ) = ( 'group', 'config', 'options', 'inputs', 'outputs' ) IO_PROPERTIES = ( NAME, DESCRIPTION, TYPE, DEFAULT, ERROR_OUTPUT ) = ( 'name', 'description', 'type', 'default', 'error_output' ) input_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name of the input.'), required=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the input.') ), TYPE: properties.Schema( properties.Schema.STRING, _('Type of the value of the input.'), default='String', constraints=[constraints.AllowedValues(( 'String', 'Number', 'CommaDelimitedList', 'Json'))] ), DEFAULT: properties.Schema( properties.Schema.STRING, _('Default value for the input if none is specified.'), ), } output_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name of the output.'), required=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the output.') ), TYPE: properties.Schema( properties.Schema.STRING, _('Type of the value of the output.'), default='String', constraints=[constraints.AllowedValues(( 'String', 'Number', 'CommaDelimitedList', 'Json'))] ), ERROR_OUTPUT: properties.Schema( properties.Schema.BOOLEAN, _('Denotes that the deployment is in an error state if this ' 'output has a value.'), default=False ) } properties_schema = { GROUP: properties.Schema( properties.Schema.STRING, _('Namespace to group this software config by when delivered to ' 'a server. This may imply what configuration tool is going to ' 'perform the configuration.'), default='Heat::Ungrouped' ), CONFIG: properties.Schema( properties.Schema.STRING, _('Configuration script or manifest which specifies what actual ' 'configuration is performed.'), ), OPTIONS: properties.Schema( properties.Schema.MAP, _('Map containing options specific to the configuration ' 'management tool used by this resource.'), ), INPUTS: properties.Schema( properties.Schema.LIST, _('Schema representing the inputs that this software config is ' 'expecting.'), schema=properties.Schema(properties.Schema.MAP, schema=input_schema) ), OUTPUTS: properties.Schema( properties.Schema.LIST, _('Schema representing the outputs that this software config ' 'will produce.'), schema=properties.Schema(properties.Schema.MAP, schema=output_schema) ), } attributes_schema = { "config": _("The config value of the software config.") } def handle_create(self): props = dict(self.properties) props[self.NAME] = self.physical_resource_name() sc = self.heat().software_configs.create(**props) self.resource_id_set(sc.id) def handle_delete(self): if self.resource_id is None: return try: self.heat().software_configs.delete(self.resource_id) except heat_exp.HTTPNotFound: logger.debug( _('Software config %s is not found.') % self.resource_id) def _resolve_attribute(self, name): ''' "config" returns the config value of the software config. If the software config does not exist, returns an empty string. ''' if name == self.CONFIG and self.resource_id: try: return self.get_software_config(self.heat(), self.resource_id) except exception.SoftwareConfigMissing: return '' @staticmethod def get_software_config(heat_client, software_config_id): ''' Get the software config specified by :software_config_id: :param heat_client: the heat client to use :param software_config_id: the ID of the config to look for :returns: the config script string for :software_config_id: :raises: exception.NotFound ''' try: return heat_client.software_configs.get(software_config_id).config except heat_exp.HTTPNotFound: raise exception.SoftwareConfigMissing( software_config_id=software_config_id) def resource_mapping(): return { 'OS::Heat::SoftwareConfig': SoftwareConfig, } heat-2014.1.5/heat/engine/resources/software_config/multi_part.py0000664000567000056700000001271112540642614026144 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. import email from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText import os from heat.common import exception from heat.engine import constraints from heat.engine import properties from heat.engine.resources.software_config import software_config from heat.openstack.common.gettextutils import _ class MultipartMime(software_config.SoftwareConfig): ''' A resource which assembles a collection of software configurations as a multi-part mime message. Parts in the message can be populated with inline configuration or references to other config resources. If the referenced resource is itself a valid multi-part mime message, that will be broken into parts and those parts appended to this message. The resulting multi-part mime message will be stored by the configs API and can be referenced in properties such as OS::Nova::Server user_data. This resource is generally used to build a list of cloud-init configuration elements including scripts and cloud-config. Since cloud-init is boot-only configuration, any changes to the definition will result in the replacement of all servers which reference it. ''' PROPERTIES = ( PARTS, CONFIG, FILENAME, TYPE, SUBTYPE ) = ( 'parts', 'config', 'filename', 'type', 'subtype' ) TYPES = ( TEXT, MULTIPART ) = ( 'text', 'multipart' ) properties_schema = { PARTS: properties.Schema( properties.Schema.LIST, _('Parts belonging to this messsage.'), default=[], schema=properties.Schema( properties.Schema.MAP, schema={ CONFIG: properties.Schema( properties.Schema.STRING, _('Content of part to attach, either inline or by ' 'referencing the ID of another software config ' 'resource'), required=True ), FILENAME: properties.Schema( properties.Schema.STRING, _('Optional filename to associate with part.') ), TYPE: properties.Schema( properties.Schema.STRING, _('Whether the part content is text or multipart.'), default=TEXT, constraints=[constraints.AllowedValues(TYPES)] ), SUBTYPE: properties.Schema( properties.Schema.STRING, _('Optional subtype to specify with the type.') ), } ) ) } message = None def handle_create(self): props = {self.NAME: self.physical_resource_name()} props[self.CONFIG] = self.get_message() sc = self.heat().software_configs.create(**props) self.resource_id_set(sc.id) def get_message(self): if self.message: return self.message subparts = [] for item in self.properties.get(self.PARTS): config = item.get(self.CONFIG) part_type = item.get(self.TYPE, self.TEXT) part = config try: part = self.get_software_config(self.heat(), config) except exception.SoftwareConfigMissing: pass if part_type == self.MULTIPART: self._append_multiparts(subparts, part) else: filename = item.get(self.FILENAME, '') subtype = item.get(self.SUBTYPE, '') self._append_part(subparts, part, subtype, filename) mime_blob = MIMEMultipart(_subparts=subparts) self.message = mime_blob.as_string() return self.message @staticmethod def _append_multiparts(subparts, multi_part): multi_parts = email.message_from_string(multi_part) if not multi_parts or not multi_parts.is_multipart(): return for part in multi_parts.get_payload(): MultipartMime._append_part( subparts, part.get_payload(), part.get_content_subtype(), part.get_filename()) @staticmethod def _append_part(subparts, part, subtype, filename): if not subtype and filename: subtype = os.path.splitext(filename)[0] msg = MultipartMime._create_message(part, subtype, filename) subparts.append(msg) @staticmethod def _create_message(part, subtype, filename): msg = MIMEText(part, _subtype=subtype) if subtype else MIMEText(part) if filename: msg.add_header('Content-Disposition', 'attachment', filename=filename) return msg def resource_mapping(): return { 'OS::Heat::MultipartMime': MultipartMime, } heat-2014.1.5/heat/engine/resources/swift.py0000664000567000056700000001435312540642614021745 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. from heat.common import exception from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils logger = logging.getLogger(__name__) class SwiftContainer(resource.Resource): PROPERTIES = ( NAME, X_CONTAINER_READ, X_CONTAINER_WRITE, X_CONTAINER_META, X_ACCOUNT_META ) = ( 'name', 'X-Container-Read', 'X-Container-Write', 'X-Container-Meta', 'X-Account-Meta' ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the container. If not specified, a unique name will ' 'be generated.') ), X_CONTAINER_READ: properties.Schema( properties.Schema.STRING, _('Specify the ACL permissions on who can read objects in the ' 'container.') ), X_CONTAINER_WRITE: properties.Schema( properties.Schema.STRING, _('Specify the ACL permissions on who can write objects to the ' 'container.') ), X_CONTAINER_META: properties.Schema( properties.Schema.MAP, _('A map of user-defined meta data to associate with the ' 'container. Each key in the map will set the header ' 'X-Container-Meta-{key} with the corresponding value.'), default={} ), X_ACCOUNT_META: properties.Schema( properties.Schema.MAP, _('A map of user-defined meta data to associate with the ' 'account. Each key in the map will set the header ' 'X-Account-Meta-{key} with the corresponding value.'), default={} ), } attributes_schema = { 'DomainName': _('The host from the container URL.'), 'WebsiteURL': _('The URL of the container.'), 'RootURL': _('The parent URL of the container.'), 'ObjectCount': _('The number of objects stored in the container.'), 'BytesUsed': _('The number of bytes stored in the container.'), 'HeadContainer': _('A map containing all headers for the container.') } def physical_resource_name(self): name = self.properties.get(self.NAME) if name: return name return super(SwiftContainer, self).physical_resource_name() @staticmethod def _build_meta_headers(obj_type, meta_props): ''' Returns a new dict where each key is prepended with: X-Container-Meta- ''' if meta_props is None: return {} return dict( ('X-' + obj_type.title() + '-Meta-' + k, v) for (k, v) in meta_props.items()) def handle_create(self): """Create a container.""" container = self.physical_resource_name() container_headers = SwiftContainer._build_meta_headers( "container", self.properties[self.X_CONTAINER_META]) account_headers = SwiftContainer._build_meta_headers( "account", self.properties[self.X_ACCOUNT_META]) for key in (self.X_CONTAINER_READ, self.X_CONTAINER_WRITE): if self.properties.get(key) is not None: container_headers[key] = self.properties[key] logger.debug(_('SwiftContainer create container %(container)s with ' 'container headers %(container_headers)s and ' 'account headers %(account_headers)s') % { 'container': container, 'account_headers': account_headers, 'container_headers': container_headers}) self.swift().put_container(container, container_headers) if account_headers: self.swift().post_account(account_headers) self.resource_id_set(container) def handle_delete(self): """Perform specified delete policy.""" logger.debug(_('SwiftContainer delete container %s') % self.resource_id) if self.resource_id is not None: try: self.swift().delete_container(self.resource_id) except clients.swiftclient.ClientException as ex: logger.warn(_("Delete container failed: %s") % str(ex)) def FnGetRefId(self): return unicode(self.resource_id) def FnGetAtt(self, key): parsed = list(urlutils.urlparse(self.swift().url)) if key == 'DomainName': return parsed[1].split(':')[0] elif key == 'WebsiteURL': return '%s://%s%s/%s' % (parsed[0], parsed[1], parsed[2], self.resource_id) elif key == 'RootURL': return '%s://%s%s' % (parsed[0], parsed[1], parsed[2]) elif self.resource_id and key in ( 'ObjectCount', 'BytesUsed', 'HeadContainer'): try: headers = self.swift().head_container(self.resource_id) except clients.swiftclient.ClientException as ex: logger.warn(_("Head container failed: %s") % str(ex)) return None else: if key == 'ObjectCount': return headers['x-container-object-count'] elif key == 'BytesUsed': return headers['x-container-bytes-used'] elif key == 'HeadContainer': return headers else: raise exception.InvalidTemplateAttribute(resource=self.name, key=key) def resource_mapping(): if clients.swiftclient is None: return {} return { 'OS::Swift::Container': SwiftContainer, } heat-2014.1.5/heat/engine/resources/neutron/0000775000567000056700000000000012540643116021721 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/neutron/metering.py0000664000567000056700000001153512540642614024114 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. from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import neutron if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException class MeteringLabel(neutron.NeutronResource): """ A resource for creating neutron metering label. """ PROPERTIES = ( NAME, DESCRIPTION, ) = ( 'name', 'description', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name of the metering label.') ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the metering label.'), ) } attributes_schema = { 'name': _('Name of the metering label.'), 'description': _('Description of the metering label.'), } def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) metering_label = self.neutron().create_metering_label( {'metering_label': props})['metering_label'] self.resource_id_set(metering_label['id']) def _show_resource(self): return self.neutron().show_metering_label( self.resource_id)['metering_label'] def handle_delete(self): try: self.neutron().delete_metering_label(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class MeteringRule(neutron.NeutronResource): """ A resource to create rule for some label. """ PROPERTIES = ( METERING_LABEL_ID, REMOTE_IP_PREFIX, DIRECTION, EXCLUDED, ) = ( 'metering_label_id', 'remote_ip_prefix', 'direction', 'excluded', ) properties_schema = { METERING_LABEL_ID: properties.Schema( properties.Schema.STRING, _('The metering label ID to associate with this metering rule.'), required=True ), REMOTE_IP_PREFIX: properties.Schema( properties.Schema.STRING, _('Indicates remote IP prefix to be associated with this ' 'metering rule.'), required=True, ), DIRECTION: properties.Schema( properties.Schema.STRING, _('The direction in which metering rule is applied, ' 'either ingress or egress.'), default='ingress', constraints=[constraints.AllowedValues(( 'ingress', 'egress'))] ), EXCLUDED: properties.Schema( properties.Schema.BOOLEAN, _('Specify whether the remote_ip_prefix will be excluded or ' 'not from traffic counters of the metering label. For example ' 'to not count the traffic of a specific IP address of a range.'), default='False' ) } attributes_schema = { 'direction': _('The direction in which metering rule is applied.'), 'excluded': _('Exclude state for cidr.'), 'metering_label_id': _('The metering label ID to associate with ' 'this metering rule..'), 'remote_ip_prefix': _('CIDR to be associated with this metering ' 'rule.'), } def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) metering_label_rule = self.neutron().create_metering_label_rule( {'metering_label_rule': props})['metering_label_rule'] self.resource_id_set(metering_label_rule['id']) def _show_resource(self): return self.neutron().show_metering_label_rule( self.resource_id)['metering_label_rule'] def handle_delete(self): try: self.neutron().delete_metering_label_rule(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::MeteringLabel': MeteringLabel, 'OS::Neutron::MeteringRule': MeteringRule, } heat-2014.1.5/heat/engine/resources/neutron/port.py0000664000567000056700000002123312540642614023262 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. from heat.engine import clients from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.engine.resources.neutron import subnet from heat.openstack.common import log as logging if clients.neutronclient is not None: import neutronclient.common.exceptions as neutron_exp logger = logging.getLogger(__name__) class Port(neutron.NeutronResource): PROPERTIES = ( NETWORK_ID, NAME, VALUE_SPECS, ADMIN_STATE_UP, FIXED_IPS, MAC_ADDRESS, DEVICE_ID, SECURITY_GROUPS, ALLOWED_ADDRESS_PAIRS, DEVICE_OWNER, ) = ( 'network_id', 'name', 'value_specs', 'admin_state_up', 'fixed_ips', 'mac_address', 'device_id', 'security_groups', 'allowed_address_pairs', 'device_owner', ) _FIXED_IP_KEYS = ( FIXED_IP_SUBNET_ID, FIXED_IP_IP_ADDRESS, ) = ( 'subnet_id', 'ip_address', ) _ALLOWED_ADDRESS_PAIR_KEYS = ( ALLOWED_ADDRESS_PAIR_MAC_ADDRESS, ALLOWED_ADDRESS_PAIR_IP_ADDRESS, ) = ( 'mac_address', 'ip_address', ) properties_schema = { NETWORK_ID: properties.Schema( properties.Schema.STRING, _('Network ID this port belongs to.'), required=True ), NAME: properties.Schema( properties.Schema.STRING, _('A symbolic name for this port.'), update_allowed=True ), VALUE_SPECS: properties.Schema( properties.Schema.MAP, _('Extra parameters to include in the "port" object in the ' 'creation request.'), default={} ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('The administrative state of this port.'), default=True, update_allowed=True ), FIXED_IPS: properties.Schema( properties.Schema.LIST, _('Desired IPs for this port.'), default=[], schema=properties.Schema( properties.Schema.MAP, schema={ FIXED_IP_SUBNET_ID: properties.Schema( properties.Schema.STRING, _('Subnet in which to allocate the IP address for ' 'this port.') ), FIXED_IP_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('IP address desired in the subnet for this port.') ), }, ), update_allowed=True ), MAC_ADDRESS: properties.Schema( properties.Schema.STRING, _('MAC address to give to this port.') ), DEVICE_ID: properties.Schema( properties.Schema.STRING, _('Device ID of this port.'), update_allowed=True ), SECURITY_GROUPS: properties.Schema( properties.Schema.LIST, _('Security group IDs to associate with this port.'), default=[], update_allowed=True ), ALLOWED_ADDRESS_PAIRS: properties.Schema( properties.Schema.LIST, _('Additional MAC/IP address pairs allowed to pass through the ' 'port.'), schema=properties.Schema( properties.Schema.MAP, schema={ ALLOWED_ADDRESS_PAIR_MAC_ADDRESS: properties.Schema( properties.Schema.STRING, _('MAC address to allow through this port.') ), ALLOWED_ADDRESS_PAIR_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('IP address to allow through this port.'), required=True ), }, ) ), DEVICE_OWNER: properties.Schema( properties.Schema.STRING, _('Name of the network owning the port. ' 'The value is typically network:floatingip ' 'or network:router_interface or network:dhcp'), update_allowed=True ), } attributes_schema = { "admin_state_up": _("The administrative state of this port."), "device_id": _("Unique identifier for the device."), "device_owner": _("Name of the network owning the port."), "fixed_ips": _("Fixed IP addresses."), "mac_address": _("MAC address of the port."), "name": _("Friendly name of the port."), "network_id": _("Unique identifier for the network owning the port."), "security_groups": _("A list of security groups for the port."), "status": _("The status of the port."), "tenant_id": _("Tenant owning the port."), "allowed_address_pairs": _("Additional MAC/IP address pairs allowed " "to pass through a port."), "show": _("All attributes."), } update_allowed_keys = ('Properties',) def add_dependencies(self, deps): super(Port, self).add_dependencies(deps) # Depend on any Subnet in this template with the same # network_id as this network_id. # It is not known which subnet a port might be assigned # to so all subnets in a network should be created before # the ports in that network. for resource in self.stack.itervalues(): if (resource.has_interface('OS::Neutron::Subnet') and resource.properties.get(subnet.Subnet.NETWORK_ID) == self.properties.get(self.NETWORK_ID)): deps += (self, resource) def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) self._prepare_list_properties(props) if not props['fixed_ips']: del(props['fixed_ips']) port = self.neutron().create_port({'port': props})['port'] self.resource_id_set(port['id']) def _prepare_list_properties(self, props): for fixed_ip in props.get(self.FIXED_IPS, []): for key, value in fixed_ip.items(): if value is None: fixed_ip.pop(key) # delete empty MAC addresses so that Neutron validation code # wouldn't fail as it not accepts Nones for pair in props.get(self.ALLOWED_ADDRESS_PAIRS, []): if (self.ALLOWED_ADDRESS_PAIR_MAC_ADDRESS in pair and pair[self.ALLOWED_ADDRESS_PAIR_MAC_ADDRESS] is None): del pair[self.ALLOWED_ADDRESS_PAIR_MAC_ADDRESS] if props.get(self.SECURITY_GROUPS): props[self.SECURITY_GROUPS] = self.get_secgroup_uuids( props.get(self.SECURITY_GROUPS), self.neutron()) else: props.pop(self.SECURITY_GROUPS, None) def _show_resource(self): return self.neutron().show_port( self.resource_id)['port'] def check_create_complete(self, *args): attributes = self._show_resource() return self.is_built(attributes) def handle_delete(self): client = self.neutron() try: client.delete_port(self.resource_id) except neutron_exp.NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def _handle_not_found_exception(self, ex): # raise any exception which is not for a not found port if not (ex.status_code == 404 or isinstance(ex, neutron_exp.PortNotFoundClient)): raise ex def handle_update(self, json_snippet, tmpl_diff, prop_diff): props = self.prepare_update_properties(json_snippet) self._prepare_list_properties(props) logger.debug(_('updating port with %s') % props) self.neutron().update_port(self.resource_id, {'port': props}) def check_update_complete(self, *args): attributes = self._show_resource() return self.is_built(attributes) def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::Port': Port, } heat-2014.1.5/heat/engine/resources/neutron/security_group.py0000664000567000056700000002167512540642614025373 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. from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging if clients.neutronclient is not None: import neutronclient.common.exceptions as neutron_exp logger = logging.getLogger(__name__) class SecurityGroup(neutron.NeutronResource): PROPERTIES = ( NAME, DESCRIPTION, RULES, ) = ( 'name', 'description', 'rules', ) _RULE_KEYS = ( RULE_DIRECTION, RULE_ETHERTYPE, RULE_PORT_RANGE_MIN, RULE_PORT_RANGE_MAX, RULE_PROTOCOL, RULE_REMOTE_MODE, RULE_REMOTE_GROUP_ID, RULE_REMOTE_IP_PREFIX, ) = ( 'direction', 'ethertype', 'port_range_min', 'port_range_max', 'protocol', 'remote_mode', 'remote_group_id', 'remote_ip_prefix', ) _rule_schema = { RULE_DIRECTION: properties.Schema( properties.Schema.STRING, _('The direction in which the security group rule is applied. ' 'For a compute instance, an ingress security group rule ' 'matches traffic that is incoming (ingress) for that ' 'instance. An egress rule is applied to traffic leaving ' 'the instance.'), default='ingress', constraints=[ constraints.AllowedValues(['ingress', 'egress']), ] ), RULE_ETHERTYPE: properties.Schema( properties.Schema.STRING, _('Ethertype of the traffic.'), default='IPv4', constraints=[ constraints.AllowedValues(['IPv4', 'IPv6']), ] ), RULE_PORT_RANGE_MIN: properties.Schema( properties.Schema.INTEGER, _('The minimum port number in the range that is matched by the ' 'security group rule. If the protocol is TCP or UDP, this ' 'value must be less than or equal to the value of the ' 'port_range_max attribute. If the protocol is ICMP, this ' 'value must be an ICMP type.') ), RULE_PORT_RANGE_MAX: properties.Schema( properties.Schema.INTEGER, _('The maximum port number in the range that is matched by the ' 'security group rule. The port_range_min attribute constrains ' 'the port_range_max attribute. If the protocol is ICMP, this ' 'value must be an ICMP type.') ), RULE_PROTOCOL: properties.Schema( properties.Schema.STRING, _('The protocol that is matched by the security group rule. ' 'Valid values include tcp, udp, and icmp.') ), RULE_REMOTE_MODE: properties.Schema( properties.Schema.STRING, _('Whether to specify a remote group or a remote IP prefix.'), default='remote_ip_prefix', constraints=[ constraints.AllowedValues(['remote_ip_prefix', 'remote_group_id']), ] ), RULE_REMOTE_GROUP_ID: properties.Schema( properties.Schema.STRING, _('The remote group ID to be associated with this security group ' 'rule. If no value is specified then this rule will use this ' 'security group for the remote_group_id.') ), RULE_REMOTE_IP_PREFIX: properties.Schema( properties.Schema.STRING, _('The remote IP prefix (CIDR) to be associated with this ' 'security group rule.') ), } properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('A string specifying a symbolic name for the security group, ' 'which is not required to be unique.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the security group.'), update_allowed=True ), RULES: properties.Schema( properties.Schema.LIST, _('List of security group rules.'), default=[], schema=properties.Schema( properties.Schema.MAP, schema=_rule_schema ), update_allowed=True ), } default_egress_rules = [ {"direction": "egress", "ethertype": "IPv4"}, {"direction": "egress", "ethertype": "IPv6"} ] update_allowed_keys = ('Properties',) def validate(self): super(SecurityGroup, self).validate() if self.properties.get(self.NAME) == 'default': msg = _('Security groups cannot be assigned the name "default".') raise exception.StackValidationFailed(message=msg) def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) rules = props.pop(self.RULES, []) sec = self.neutron().create_security_group( {'security_group': props})['security_group'] self.resource_id_set(sec['id']) self._create_rules(rules) def _format_rule(self, r): rule = dict(r) rule['security_group_id'] = self.resource_id if 'remote_mode' in rule: remote_mode = rule.get(self.RULE_REMOTE_MODE) del(rule[self.RULE_REMOTE_MODE]) if remote_mode == self.RULE_REMOTE_GROUP_ID: rule[self.RULE_REMOTE_IP_PREFIX] = None if not rule.get(self.RULE_REMOTE_GROUP_ID): # if remote group is not specified then make this # a self-referencing rule rule[self.RULE_REMOTE_GROUP_ID] = self.resource_id else: rule[self.RULE_REMOTE_GROUP_ID] = None for key in (self.RULE_PORT_RANGE_MIN, self.RULE_PORT_RANGE_MAX): if rule.get(key) is not None: rule[key] = str(rule[key]) return rule def _create_rules(self, rules): egress_deleted = False for i in rules: if i[self.RULE_DIRECTION] == 'egress' and not egress_deleted: # There is at least one egress rule, so delete the default # rules which allow all egress traffic egress_deleted = True def is_egress(rule): return rule[self.RULE_DIRECTION] == 'egress' self._delete_rules(is_egress) rule = self._format_rule(i) try: self.neutron().create_security_group_rule( {'security_group_rule': rule}) except neutron_exp.NeutronClientException as ex: # ignore error if rule already exists if ex.status_code != 409: raise def _delete_rules(self, to_delete=None): try: sec = self.neutron().show_security_group( self.resource_id)['security_group'] except neutron_exp.NeutronClientException as ex: self._handle_not_found_exception(ex) else: for rule in sec['security_group_rules']: if to_delete is None or to_delete(rule): try: self.neutron().delete_security_group_rule(rule['id']) except neutron_exp.NeutronClientException as ex: self._handle_not_found_exception(ex) def handle_delete(self): if self.resource_id is None: return self._delete_rules() try: self.neutron().delete_security_group(self.resource_id) except neutron_exp.NeutronClientException as ex: self._handle_not_found_exception(ex) self.resource_id_set(None) def handle_update(self, json_snippet, tmpl_diff, prop_diff): props = self.prepare_update_properties(json_snippet) rules = props.pop(self.RULES, []) self.neutron().update_security_group( self.resource_id, {'security_group': props}) # handle rules changes by: # * deleting all rules # * restoring the default egress rules # * creating new rules self._delete_rules() self._create_rules(self.default_egress_rules) if rules: self._create_rules(rules) def resource_mapping(): return { 'OS::Neutron::SecurityGroup': SecurityGroup, } heat-2014.1.5/heat/engine/resources/neutron/neutron.py0000664000567000056700000001374212540642614023776 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. from neutronclient.common.exceptions import NeutronClientException from heat.common import exception from heat.engine.properties import Properties from heat.engine import resource from heat.engine import scheduler from heat.openstack.common import log as logging from heat.openstack.common import uuidutils logger = logging.getLogger(__name__) class NeutronResource(resource.Resource): def validate(self): ''' Validate any of the provided params ''' res = super(NeutronResource, self).validate() if res: return res return self.validate_properties(self.properties) @staticmethod def validate_properties(properties): ''' Validates to ensure nothing in value_specs overwrites any key that exists in the schema. Also ensures that shared and tenant_id is not specified in value_specs. ''' if 'value_specs' in properties.keys(): vs = properties.get('value_specs') banned_keys = set(['shared', 'tenant_id']).union( properties.keys()) for k in banned_keys.intersection(vs.keys()): return '%s not allowed in value_specs' % k @staticmethod def prepare_properties(properties, name): ''' Prepares the property values so that they can be passed directly to the Neutron create call. Removes None values and value_specs, merges value_specs with the main values. ''' props = dict((k, v) for k, v in properties.items() if v is not None and k != 'value_specs') if 'name' in properties.keys(): props.setdefault('name', name) if 'value_specs' in properties.keys(): props.update(properties.get('value_specs')) return props def prepare_update_properties(self, json_snippet): ''' Prepares the property values so that they can be passed directly to the Neutron update call. Removes any properties which are not update_allowed, then processes as for prepare_properties. ''' p = Properties(self.properties_schema, json_snippet.get('Properties', {}), self._resolve_runtime_data, self.name, self.context) update_props = dict((k, v) for k, v in p.items() if p.props.get(k).schema.update_allowed) props = self.prepare_properties( update_props, self.physical_resource_name()) return props @staticmethod def handle_get_attributes(name, key, attributes): ''' Support method for responding to FnGetAtt ''' if key == 'show': return attributes if key in attributes.keys(): return attributes[key] raise exception.InvalidTemplateAttribute(resource=name, key=key) @staticmethod def is_built(attributes): if attributes['status'] == 'BUILD': return False if attributes['status'] in ('ACTIVE', 'DOWN'): return True else: raise exception.Error(_('neutron reported unexpected ' 'resource[%(name)s] status[%(status)s]') % {'name': attributes['name'], 'status': attributes['status']}) def _resolve_attribute(self, name): try: attributes = self._show_resource() except NeutronClientException as ex: logger.warn(_("failed to fetch resource attributes: %s") % str(ex)) return None return self.handle_get_attributes(self.name, name, attributes) def _confirm_delete(self): while True: try: yield self._show_resource() except NeutronClientException as ex: self._handle_not_found_exception(ex) return def _handle_not_found_exception(self, ex): if ex.status_code != 404: raise ex def FnGetRefId(self): return unicode(self.resource_id) @staticmethod def get_secgroup_uuids(security_groups, client): ''' Returns a list of security group UUIDs. Args: security_groups: List of security group names or UUIDs client: reference to neutronclient ''' seclist = [] all_groups = None for sg in security_groups: if uuidutils.is_uuid_like(sg): seclist.append(sg) else: if not all_groups: response = client.list_security_groups() all_groups = response['security_groups'] groups = [g['id'] for g in all_groups if g['name'] == sg] if len(groups) == 0: raise exception.PhysicalResourceNotFound(resource_id=sg) if len(groups) > 1: raise exception.PhysicalResourceNameAmbiguity(name=sg) seclist.append(groups[0]) return seclist def _delete_task(self): delete_task = scheduler.TaskRunner(self._confirm_delete) delete_task.start() return delete_task def check_delete_complete(self, delete_task): # if the resource was already deleted, delete_task will be None return delete_task is None or delete_task.step() heat-2014.1.5/heat/engine/resources/neutron/vpnservice.py0000664000567000056700000005157612540642614024477 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. from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException logger = logging.getLogger(__name__) class VPNService(neutron.NeutronResource): """ A resource for VPN service in Neutron. """ PROPERTIES = ( NAME, DESCRIPTION, ADMIN_STATE_UP, SUBNET_ID, ROUTER_ID, ) = ( 'name', 'description', 'admin_state_up', 'subnet_id', 'router_id', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the vpn service.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the vpn service.'), update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('Administrative state for the vpn service.'), default=True, update_allowed=True ), SUBNET_ID: properties.Schema( properties.Schema.STRING, _('Unique identifier for the subnet in which the vpn service ' 'will be created.'), required=True ), ROUTER_ID: properties.Schema( properties.Schema.STRING, _('Unique identifier for the router to which the vpn service ' 'will be inserted.'), required=True ), } attributes_schema = { 'admin_state_up': _('The administrative state of the vpn service.'), 'description': _('The description of the vpn service.'), 'name': _('The name of the vpn service.'), 'router_id': _('The unique identifier of the router to which the vpn ' 'service was inserted.'), 'status': _('The status of the vpn service.'), 'subnet_id': _('The unique identifier of the subnet in which the vpn ' 'service was created.'), 'tenant_id': _('The unique identifier of the tenant owning the vpn ' 'service.'), 'show': _('All attributes.'), } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_vpnservice(self.resource_id)['vpnservice'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) vpnservice = self.neutron().create_vpnservice({'vpnservice': props})[ 'vpnservice'] self.resource_id_set(vpnservice['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_vpnservice(self.resource_id, {'vpnservice': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_vpnservice(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class IPsecSiteConnection(neutron.NeutronResource): """ A resource for IPsec site connection in Neutron. """ PROPERTIES = ( NAME, DESCRIPTION, PEER_ADDRESS, PEER_ID, PEER_CIDRS, MTU, DPD, PSK, INITIATOR, ADMIN_STATE_UP, IKEPOLICY_ID, IPSECPOLICY_ID, VPNSERVICE_ID, ) = ( 'name', 'description', 'peer_address', 'peer_id', 'peer_cidrs', 'mtu', 'dpd', 'psk', 'initiator', 'admin_state_up', 'ikepolicy_id', 'ipsecpolicy_id', 'vpnservice_id', ) _DPD_KEYS = ( DPD_ACTIONS, DPD_INTERVAL, DPD_TIMEOUT, ) = ( 'actions', 'interval', 'timeout', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the ipsec site connection.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the ipsec site connection.'), update_allowed=True ), PEER_ADDRESS: properties.Schema( properties.Schema.STRING, _('Remote branch router public IPv4 address or IPv6 address or ' 'FQDN.'), required=True ), PEER_ID: properties.Schema( properties.Schema.STRING, _('Remote branch router identity.'), required=True ), PEER_CIDRS: properties.Schema( properties.Schema.LIST, _('Remote subnet(s) in CIDR format.'), required=True ), MTU: properties.Schema( properties.Schema.INTEGER, _('Maximum transmission unit size (in bytes) for the ipsec site ' 'connection.'), default=1500 ), DPD: properties.Schema( properties.Schema.MAP, _('Dead Peer Detection protocol configuration for the ipsec site ' 'connection.'), schema={ DPD_ACTIONS: properties.Schema( properties.Schema.STRING, _('Controls DPD protocol mode.'), default='hold', constraints=[ constraints.AllowedValues(['clear', 'disabled', 'hold', 'restart', 'restart-by-peer']), ] ), DPD_INTERVAL: properties.Schema( properties.Schema.INTEGER, _('Number of seconds for the DPD delay.'), default=30 ), DPD_TIMEOUT: properties.Schema( properties.Schema.INTEGER, _('Number of seconds for the DPD timeout.'), default=120 ), } ), PSK: properties.Schema( properties.Schema.STRING, _('Pre-shared key string for the ipsec site connection.'), required=True ), INITIATOR: properties.Schema( properties.Schema.STRING, _('Initiator state in lowercase for the ipsec site connection.'), default='bi-directional', constraints=[ constraints.AllowedValues(['bi-directional', 'response-only']), ] ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('Administrative state for the ipsec site connection.'), default=True, update_allowed=True ), IKEPOLICY_ID: properties.Schema( properties.Schema.STRING, _('Unique identifier for the ike policy associated with the ' 'ipsec site connection.'), required=True ), IPSECPOLICY_ID: properties.Schema( properties.Schema.STRING, _('Unique identifier for the ipsec policy associated with the ' 'ipsec site connection.'), required=True ), VPNSERVICE_ID: properties.Schema( properties.Schema.STRING, _('Unique identifier for the vpn service associated with the ' 'ipsec site connection.'), required=True ), } attributes_schema = { 'admin_state_up': _('The administrative state of the ipsec site ' 'connection.'), 'auth_mode': _('The authentication mode of the ipsec site ' 'connection.'), 'description': _('The description of the ipsec site connection.'), 'dpd': _('The dead peer detection protocol configuration of the ipsec ' 'site connection.'), 'ikepolicy_id': _('The unique identifier of ike policy associated ' 'with the ipsec site connection.'), 'initiator': _('The initiator of the ipsec site connection.'), 'ipsecpolicy_id': _('The unique identifier of ipsec policy ' 'associated with the ipsec site connection.'), 'mtu': _('The maximum transmission unit size (in bytes) of the ipsec ' 'site connection.'), 'name': _('The name of the ipsec site connection.'), 'peer_address': _('The remote branch router public IPv4 address or ' 'IPv6 address or FQDN.'), 'peer_cidrs': _('The remote subnet(s) in CIDR format of the ipsec ' 'site connection.'), 'peer_id': _('The remote branch router identity of the ipsec site ' 'connection.'), 'psk': _('The pre-shared key string of the ipsec site connection.'), 'route_mode': _('The route mode of the ipsec site connection.'), 'status': _('The status of the ipsec site connection.'), 'tenant_id': _('The unique identifier of the tenant owning the ipsec ' 'site connection.'), 'vpnservice_id': _('The unique identifier of vpn service associated ' 'with the ipsec site connection.') } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_ipsec_site_connection(self.resource_id)[ 'ipsec_site_connection'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) ipsec_site_connection = self.neutron().create_ipsec_site_connection( {'ipsec_site_connection': props})['ipsec_site_connection'] self.resource_id_set(ipsec_site_connection['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_ipsec_site_connection( self.resource_id, {'ipsec_site_connection': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_ipsec_site_connection(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class IKEPolicy(neutron.NeutronResource): """ A resource for IKE policy in Neutron. """ PROPERTIES = ( NAME, DESCRIPTION, AUTH_ALGORITHM, ENCRYPTION_ALGORITHM, PHASE1_NEGOTIATION_MODE, LIFETIME, PFS, IKE_VERSION, ) = ( 'name', 'description', 'auth_algorithm', 'encryption_algorithm', 'phase1_negotiation_mode', 'lifetime', 'pfs', 'ike_version', ) _LIFETIME_KEYS = ( LIFETIME_UNITS, LIFETIME_VALUE, ) = ( 'units', 'value', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the ike policy.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the ike policy.'), update_allowed=True ), AUTH_ALGORITHM: properties.Schema( properties.Schema.STRING, _('Authentication hash algorithm for the ike policy.'), default='sha1', constraints=[ constraints.AllowedValues(['sha1']), ] ), ENCRYPTION_ALGORITHM: properties.Schema( properties.Schema.STRING, _('Encryption algorithm for the ike policy.'), default='aes-128', constraints=[ constraints.AllowedValues(['3des', 'aes-128', 'aes-192', 'aes-256']), ] ), PHASE1_NEGOTIATION_MODE: properties.Schema( properties.Schema.STRING, _('Negotiation mode for the ike policy.'), default='main', constraints=[ constraints.AllowedValues(['main']), ] ), LIFETIME: properties.Schema( properties.Schema.MAP, _('Safety assessment lifetime configuration for the ike policy.'), schema={ LIFETIME_UNITS: properties.Schema( properties.Schema.STRING, _('Safety assessment lifetime units.'), default='seconds', constraints=[ constraints.AllowedValues(['seconds', 'kilobytes']), ] ), LIFETIME_VALUE: properties.Schema( properties.Schema.INTEGER, _('Safety assessment lifetime value in specified ' 'units.'), default=3600 ), } ), PFS: properties.Schema( properties.Schema.STRING, _('Perfect forward secrecy in lowercase for the ike policy.'), default='group5', constraints=[ constraints.AllowedValues(['group2', 'group5', 'group14']), ] ), IKE_VERSION: properties.Schema( properties.Schema.STRING, _('Version for the ike policy.'), default='v1', constraints=[ constraints.AllowedValues(['v1', 'v2']), ] ), } attributes_schema = { 'auth_algorithm': _('The authentication hash algorithm used by the ike' ' policy.'), 'description': _('The description of the ike policy.'), 'encryption_algorithm': _('The encryption algorithm used by the ike ' 'policy.'), 'ike_version': _('The version of the ike policy.'), 'lifetime': _('The safety assessment lifetime configuration for the ' 'ike policy.'), 'name': _('The name of the ike policy.'), 'pfs': _('The perfect forward secrecy of the ike policy.'), 'phase1_negotiation_mode': _('The negotiation mode of the ike ' 'policy.'), 'tenant_id': _('The unique identifier of the tenant owning the ike ' 'policy.'), } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_ikepolicy(self.resource_id)['ikepolicy'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) ikepolicy = self.neutron().create_ikepolicy({'ikepolicy': props})[ 'ikepolicy'] self.resource_id_set(ikepolicy['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_ikepolicy(self.resource_id, {'ikepolicy': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_ikepolicy(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class IPsecPolicy(neutron.NeutronResource): """ A resource for IPsec policy in Neutron. """ PROPERTIES = ( NAME, DESCRIPTION, TRANSFORM_PROTOCOL, ENCAPSULATION_MODE, AUTH_ALGORITHM, ENCRYPTION_ALGORITHM, LIFETIME, PFS, ) = ( 'name', 'description', 'transform_protocol', 'encapsulation_mode', 'auth_algorithm', 'encryption_algorithm', 'lifetime', 'pfs', ) _LIFETIME_KEYS = ( LIFETIME_UNITS, LIFETIME_VALUE, ) = ( 'units', 'value', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the ipsec policy.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the ipsec policy.'), update_allowed=True ), TRANSFORM_PROTOCOL: properties.Schema( properties.Schema.STRING, _('Transform protocol for the ipsec policy.'), default='esp', constraints=[ constraints.AllowedValues(['esp', 'ah', 'ah-esp']), ] ), ENCAPSULATION_MODE: properties.Schema( properties.Schema.STRING, _('Encapsulation mode for the ipsec policy.'), default='tunnel', constraints=[ constraints.AllowedValues(['tunnel', 'transport']), ] ), AUTH_ALGORITHM: properties.Schema( properties.Schema.STRING, _('Authentication hash algorithm for the ipsec policy.'), default='sha1', constraints=[ constraints.AllowedValues(['sha1']), ] ), ENCRYPTION_ALGORITHM: properties.Schema( properties.Schema.STRING, _('Encryption algorithm for the ipsec policy.'), default='aes-128', constraints=[ constraints.AllowedValues(['3des', 'aes-128', 'aes-192', 'aes-256']), ] ), LIFETIME: properties.Schema( properties.Schema.MAP, _('Safety assessment lifetime configuration for the ipsec ' 'policy.'), schema={ LIFETIME_UNITS: properties.Schema( properties.Schema.STRING, _('Safety assessment lifetime units.'), default='seconds', constraints=[ constraints.AllowedValues(['seconds', 'kilobytes']), ] ), LIFETIME_VALUE: properties.Schema( properties.Schema.INTEGER, _('Safety assessment lifetime value in specified ' 'units.'), default=3600 ), } ), PFS: properties.Schema( properties.Schema.STRING, _('Perfect forward secrecy for the ipsec policy.'), default='group5', constraints=[ constraints.AllowedValues(['group2', 'group5', 'group14']), ] ), } attributes_schema = { 'auth_algorithm': _('The authentication hash algorithm of the ipsec ' 'policy.'), 'description': _('The description of the ipsec policy.'), 'encapsulation_mode': _('The encapsulation mode of the ipsec policy.'), 'encryption_algorithm': _('The encryption algorithm of the ipsec ' 'policy.'), 'lifetime': _('The safety assessment lifetime configuration of the ' 'ipsec policy.'), 'name': _('The name of the ipsec policy.'), 'pfs': _('The perfect forward secrecy of the ipsec policy.'), 'tenant_id': _('The unique identifier of the tenant owning the ' 'ipsec policy.'), 'transform_protocol': _('The transform protocol of the ipsec policy.') } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_ipsecpolicy(self.resource_id)['ipsecpolicy'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) ipsecpolicy = self.neutron().create_ipsecpolicy( {'ipsecpolicy': props})['ipsecpolicy'] self.resource_id_set(ipsecpolicy['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_ipsecpolicy(self.resource_id, {'ipsecpolicy': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_ipsecpolicy(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::VPNService': VPNService, 'OS::Neutron::IPsecSiteConnection': IPsecSiteConnection, 'OS::Neutron::IKEPolicy': IKEPolicy, 'OS::Neutron::IPsecPolicy': IPsecPolicy, } heat-2014.1.5/heat/engine/resources/neutron/router.py0000664000567000056700000002635112540642614023624 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. from heat.common import exception from heat.engine import clients from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.engine.resources.neutron import subnet from heat.engine import support from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException from neutronclient.neutron import v2_0 as neutronV20 logger = logging.getLogger(__name__) class Router(neutron.NeutronResource): PROPERTIES = ( NAME, EXTERNAL_GATEWAY, VALUE_SPECS, ADMIN_STATE_UP, L3_AGENT_ID, ) = ( 'name', 'external_gateway_info', 'value_specs', 'admin_state_up', 'l3_agent_id', ) _EXTERNAL_GATEWAY_KEYS = ( EXTERNAL_GATEWAY_NETWORK, EXTERNAL_GATEWAY_ENABLE_SNAT, ) = ( 'network', 'enable_snat', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('The name of the router.'), update_allowed=True ), EXTERNAL_GATEWAY: properties.Schema( properties.Schema.MAP, _('External network gateway configuration for a router.'), schema={ EXTERNAL_GATEWAY_NETWORK: properties.Schema( properties.Schema.STRING, _('ID or name of the external network for the gateway.'), required=True, update_allowed=True ), EXTERNAL_GATEWAY_ENABLE_SNAT: properties.Schema( properties.Schema.BOOLEAN, _('Enables Source NAT on the router gateway. NOTE: The ' 'default policy setting in Neutron restricts usage of ' 'this property to administrative users only.'), update_allowed=True ), }, update_allowed=True ), VALUE_SPECS: properties.Schema( properties.Schema.MAP, _('Extra parameters to include in the creation request.'), default={}, update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('The administrative state of the router.'), default=True, update_allowed=True ), L3_AGENT_ID: properties.Schema( properties.Schema.STRING, _('ID of the L3 agent. NOTE: The default policy setting in ' 'Neutron restricts usage of this property to administrative ' 'users only.'), update_allowed=True ), } attributes_schema = { "status": _("The status of the router."), "external_gateway_info": _("Gateway network for the router."), "name": _("Friendly name of the router."), "admin_state_up": _("Administrative state of the router."), "tenant_id": _("Tenant owning the router."), "show": _("All attributes."), } update_allowed_keys = ('Properties',) def add_dependencies(self, deps): super(Router, self).add_dependencies(deps) external_gw = self.properties.get(self.EXTERNAL_GATEWAY) if external_gw: external_gw_net = external_gw.get(self.EXTERNAL_GATEWAY_NETWORK) for res in self.stack.itervalues(): if res.has_interface('OS::Neutron::Subnet'): subnet_net = res.properties.get(subnet.Subnet.NETWORK_ID) if subnet_net == external_gw_net: deps += (self, res) def prepare_properties(self, properties, name): props = super(Router, self).prepare_properties(properties, name) gateway = props.get(self.EXTERNAL_GATEWAY) if gateway: gateway['network_id'] = neutronV20.find_resourceid_by_name_or_id( self.neutron(), 'network', gateway.pop(self.EXTERNAL_GATEWAY_NETWORK)) if gateway[self.EXTERNAL_GATEWAY_ENABLE_SNAT] is None: del gateway[self.EXTERNAL_GATEWAY_ENABLE_SNAT] return props def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) l3_agent_id = props.pop(self.L3_AGENT_ID, None) router = self.neutron().create_router({'router': props})['router'] self.resource_id_set(router['id']) if l3_agent_id: self._replace_agent(l3_agent_id) def _show_resource(self): return self.neutron().show_router( self.resource_id)['router'] def check_create_complete(self, *args): attributes = self._show_resource() return self.is_built(attributes) def handle_delete(self): client = self.neutron() try: client.delete_router(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def handle_update(self, json_snippet, tmpl_diff, prop_diff): props = self.prepare_update_properties(json_snippet) l3_agent_id = props.pop(self.L3_AGENT_ID, None) if self.L3_AGENT_ID in prop_diff: self._replace_agent(l3_agent_id) del prop_diff[self.L3_AGENT_ID] if len(prop_diff) > 0: self.neutron().update_router( self.resource_id, {'router': props}) def _replace_agent(self, l3_agent_id=None): ret = self.neutron().list_l3_agent_hosting_routers( self.resource_id) for agent in ret['agents']: self.neutron().remove_router_from_l3_agent( agent['id'], self.resource_id) if l3_agent_id: self.neutron().add_router_to_l3_agent( l3_agent_id, {'router_id': self.resource_id}) class RouterInterface(neutron.NeutronResource): PROPERTIES = ( ROUTER_ID, SUBNET_ID, PORT_ID, ) = ( 'router_id', 'subnet_id', 'port_id', ) properties_schema = { ROUTER_ID: properties.Schema( properties.Schema.STRING, _('The router id.'), required=True ), SUBNET_ID: properties.Schema( properties.Schema.STRING, _('The subnet id, either subnet_id or port_id should be ' 'specified.') ), PORT_ID: properties.Schema( properties.Schema.STRING, _('The port id, either subnet_id or port_id should be specified.') ), } def validate(self): ''' Validate any of the provided params ''' super(RouterInterface, self).validate() subnet_id = self.properties.get(self.SUBNET_ID) port_id = self.properties.get(self.PORT_ID) if subnet_id and port_id: raise exception.ResourcePropertyConflict(self.SUBNET_ID, self.PORT_ID) if not subnet_id and not port_id: msg = 'Either subnet_id or port_id must be specified.' raise exception.StackValidationFailed(message=msg) def handle_create(self): router_id = self.properties.get(self.ROUTER_ID) key = self.SUBNET_ID value = self.properties.get(key) if not value: key = self.PORT_ID value = self.properties.get(key) self.neutron().add_interface_router( router_id, {key: value}) self.resource_id_set('%s:%s=%s' % (router_id, key, value)) def handle_delete(self): if not self.resource_id: return client = self.neutron() tokens = self.resource_id.replace('=', ':').split(':') if len(tokens) == 2: # compatible with old data tokens.insert(1, 'subnet_id') (router_id, key, value) = tokens try: client.remove_interface_router( router_id, {key: value}) except NeutronClientException as ex: self._handle_not_found_exception(ex) class RouterGateway(neutron.NeutronResource): support_status = support.SupportStatus( support.DEPRECATED, _('RouterGateway resource is deprecated and should not be used. ' 'Instead use the `external_gateway_info` property in the router ' 'resource to set up the gateway.') ) PROPERTIES = ( ROUTER_ID, NETWORK_ID, ) = ( 'router_id', 'network_id', ) properties_schema = { ROUTER_ID: properties.Schema( properties.Schema.STRING, _('ID of the router.'), required=True ), NETWORK_ID: properties.Schema( properties.Schema.STRING, _('ID of the external network for the gateway.'), required=True ), } def add_dependencies(self, deps): super(RouterGateway, self).add_dependencies(deps) for resource in self.stack.itervalues(): # depend on any RouterInterface in this template with the same # router_id as this router_id if (resource.has_interface('OS::Neutron::RouterInterface') and resource.properties.get(RouterInterface.ROUTER_ID) == self.properties.get(self.ROUTER_ID)): deps += (self, resource) # depend on any subnet in this template with the same network_id # as this network_id, as the gateway implicitly creates a port # on that subnet elif (resource.has_interface('OS::Neutron::Subnet') and resource.properties.get(subnet.Subnet.NETWORK_ID) == self.properties.get(self.NETWORK_ID)): deps += (self, resource) def handle_create(self): router_id = self.properties.get(self.ROUTER_ID) network_id = neutronV20.find_resourceid_by_name_or_id( self.neutron(), 'network', self.properties.get(self.NETWORK_ID)) self.neutron().add_gateway_router( router_id, {'network_id': network_id}) self.resource_id_set('%s:%s' % (router_id, network_id)) def handle_delete(self): if not self.resource_id: return client = self.neutron() (router_id, network_id) = self.resource_id.split(':') try: client.remove_gateway_router(router_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::Router': Router, 'OS::Neutron::RouterInterface': RouterInterface, 'OS::Neutron::RouterGateway': RouterGateway, } heat-2014.1.5/heat/engine/resources/neutron/__init__.py0000664000567000056700000000000012540642614024022 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/neutron/net.py0000664000567000056700000001560112540642614023066 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. from heat.engine import clients from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging if clients.neutronclient is not None: import neutronclient.common.exceptions as neutron_exp from neutronclient.neutron import v2_0 as neutronV20 logger = logging.getLogger(__name__) class Net(neutron.NeutronResource): PROPERTIES = ( NAME, VALUE_SPECS, ADMIN_STATE_UP, TENANT_ID, SHARED, DHCP_AGENT_IDS, ) = ( 'name', 'value_specs', 'admin_state_up', 'tenant_id', 'shared', 'dhcp_agent_ids', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('A string specifying a symbolic name for the network, which is ' 'not required to be unique.'), update_allowed=True ), VALUE_SPECS: properties.Schema( properties.Schema.MAP, _('Extra parameters to include in the "network" object in the ' 'creation request. Parameters are often specific to installed ' 'hardware or extensions.'), default={}, update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('A boolean value specifying the administrative status of the ' 'network.'), default=True, update_allowed=True ), TENANT_ID: properties.Schema( properties.Schema.STRING, _('The ID of the tenant which will own the network. Only ' 'administrative users can set the tenant identifier; this ' 'cannot be changed using authorization policies.') ), SHARED: properties.Schema( properties.Schema.BOOLEAN, _('Whether this network should be shared across all tenants. ' 'Note that the default policy setting restricts usage of this ' 'attribute to administrative users only.'), default=False, update_allowed=True ), DHCP_AGENT_IDS: properties.Schema( properties.Schema.LIST, _('The IDs of the DHCP agent to schedule the network. Note that ' 'the default policy setting in Neutron restricts usage of this ' 'property to administrative users only.'), update_allowed=True ), } attributes_schema = { "status": _("The status of the network."), "name": _("The name of the network."), "subnets": _("Subnets of this network."), "admin_state_up": _("The administrative status of the network."), "tenant_id": _("The tenant owning this network."), "show": _("All attributes."), } update_allowed_keys = ('Properties',) def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) dhcp_agent_ids = props.pop(self.DHCP_AGENT_IDS, None) net = self.neutron().create_network({'network': props})['network'] self.resource_id_set(net['id']) if dhcp_agent_ids: self._replace_dhcp_agents(dhcp_agent_ids) def _show_resource(self): return self.neutron().show_network( self.resource_id)['network'] def check_create_complete(self, *args): attributes = self._show_resource() return self.is_built(attributes) def handle_delete(self): client = self.neutron() try: client.delete_network(self.resource_id) except neutron_exp.NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def handle_update(self, json_snippet, tmpl_diff, prop_diff): props = self.prepare_update_properties(json_snippet) dhcp_agent_ids = props.pop(self.DHCP_AGENT_IDS, None) if self.DHCP_AGENT_IDS in prop_diff: if dhcp_agent_ids is not None: self._replace_dhcp_agents(dhcp_agent_ids) del prop_diff[self.DHCP_AGENT_IDS] if len(prop_diff) > 0: self.neutron().update_network( self.resource_id, {'network': props}) def check_update_complete(self, *args): attributes = self._show_resource() return self.is_built(attributes) def _handle_not_found_exception(self, ex): # raise any exception which is not for a not found network if not (ex.status_code == 404 or isinstance(ex, neutron_exp.NetworkNotFoundClient)): raise ex def _replace_dhcp_agents(self, dhcp_agent_ids): ret = self.neutron().list_dhcp_agent_hosting_networks( self.resource_id) old = set([agent['id'] for agent in ret['agents']]) new = set(dhcp_agent_ids) for dhcp_agent_id in new - old: try: self.neutron().add_network_to_dhcp_agent( dhcp_agent_id, {'network_id': self.resource_id}) except neutron_exp.NeutronClientException as ex: # if 409 is happened, the agent is already associated. if ex.status_code != 409: raise ex for dhcp_agent_id in old - new: try: self.neutron().remove_network_from_dhcp_agent( dhcp_agent_id, self.resource_id) except neutron_exp.NeutronClientException as ex: # assume 2 patterns about status_code following: # 404: the network or agent is already gone # 409: the network isn't scheduled by the dhcp_agent if ex.status_code not in (404, 409): raise ex class NetworkConstraint(object): def validate(self, value, context): try: neutron_client = clients.Clients(context).neutron() neutronV20.find_resourceid_by_name_or_id( neutron_client, 'network', value) except neutron_exp.NeutronClientException: return False else: return True def constraint_mapping(): if clients.neutronclient is None: return {} return {'neutron.network': NetworkConstraint} def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::Net': Net, } heat-2014.1.5/heat/engine/resources/neutron/subnet.py0000664000567000056700000001527112540642614023603 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. from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException logger = logging.getLogger(__name__) class Subnet(neutron.NeutronResource): PROPERTIES = ( NETWORK_ID, CIDR, VALUE_SPECS, NAME, IP_VERSION, DNS_NAMESERVERS, GATEWAY_IP, ENABLE_DHCP, ALLOCATION_POOLS, TENANT_ID, HOST_ROUTES, ) = ( 'network_id', 'cidr', 'value_specs', 'name', 'ip_version', 'dns_nameservers', 'gateway_ip', 'enable_dhcp', 'allocation_pools', 'tenant_id', 'host_routes', ) _ALLOCATION_POOL_KEYS = ( ALLOCATION_POOL_START, ALLOCATION_POOL_END, ) = ( 'start', 'end', ) _HOST_ROUTES_KEYS = ( ROUTE_DESTINATION, ROUTE_NEXTHOP, ) = ( 'destination', 'nexthop', ) properties_schema = { NETWORK_ID: properties.Schema( properties.Schema.STRING, _('The ID of the attached network.'), required=True ), CIDR: properties.Schema( properties.Schema.STRING, _('The CIDR.'), required=True ), VALUE_SPECS: properties.Schema( properties.Schema.MAP, _('Extra parameters to include in the creation request.'), default={}, update_allowed=True ), NAME: properties.Schema( properties.Schema.STRING, _('The name of the subnet.'), update_allowed=True ), IP_VERSION: properties.Schema( properties.Schema.INTEGER, _('The IP version, which is 4 or 6.'), default=4, constraints=[ constraints.AllowedValues([4, 6]), ] ), DNS_NAMESERVERS: properties.Schema( properties.Schema.LIST, _('A specified set of DNS name servers to be used.'), default=[], update_allowed=True ), GATEWAY_IP: properties.Schema( properties.Schema.STRING, _('The gateway IP address.'), update_allowed=True ), ENABLE_DHCP: properties.Schema( properties.Schema.BOOLEAN, _('Set to true if DHCP is enabled and false if DHCP is disabled.'), default=True, update_allowed=True ), ALLOCATION_POOLS: properties.Schema( properties.Schema.LIST, _('The start and end addresses for the allocation pools.'), schema=properties.Schema( properties.Schema.MAP, schema={ ALLOCATION_POOL_START: properties.Schema( properties.Schema.STRING, required=True ), ALLOCATION_POOL_END: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), TENANT_ID: properties.Schema( properties.Schema.STRING, _('The ID of the tenant who owns the network. Only administrative' ' users can specify a tenant ID other than their own.') ), HOST_ROUTES: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, schema={ ROUTE_DESTINATION: properties.Schema( properties.Schema.STRING, required=True ), ROUTE_NEXTHOP: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), } attributes_schema = { "name": _("Friendly name of the subnet."), "network_id": _("Parent network of the subnet."), "tenant_id": _("Tenant owning the subnet."), "allocation_pools": _("Ip allocation pools and their ranges."), "gateway_ip": _("Ip of the subnet's gateway."), "host_routes": _("Additional routes for this subnet."), "ip_version": _("Ip version for the subnet."), "cidr": _("CIDR block notation for this subnet."), "dns_nameservers": _("List of dns nameservers."), "enable_dhcp": _("'true' if DHCP is enabled for this subnet; 'false' " "otherwise."), "show": _("All attributes."), } update_allowed_keys = ('Properties',) @classmethod def _null_gateway_ip(cls, props): if cls.GATEWAY_IP not in props: return # Specifying null in the gateway_ip will result in # a property containing an empty string. # A null gateway_ip has special meaning in the API # so this needs to be set back to None. # See bug https://bugs.launchpad.net/heat/+bug/1226666 if props.get(cls.GATEWAY_IP) == '': props[cls.GATEWAY_IP] = None def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) self._null_gateway_ip(props) subnet = self.neutron().create_subnet({'subnet': props})['subnet'] self.resource_id_set(subnet['id']) def handle_delete(self): client = self.neutron() try: client.delete_subnet(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def _show_resource(self): return self.neutron().show_subnet(self.resource_id)['subnet'] def handle_update(self, json_snippet, tmpl_diff, prop_diff): props = self.prepare_update_properties(json_snippet) self.neutron().update_subnet( self.resource_id, {'subnet': props}) def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::Subnet': Subnet, } heat-2014.1.5/heat/engine/resources/neutron/network_gateway.py0000664000567000056700000001721612540642614025516 0ustar jenkinsjenkins00000000000000 # Copyright 2013 NTT Corp. # 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. from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException logger = logging.getLogger(__name__) class NetworkGateway(neutron.NeutronResource): ''' A resource for the Network Gateway resource in Neutron Network Gateway. ''' PROPERTIES = ( NAME, DEVICES, CONNECTIONS, ) = ( 'name', 'devices', 'connections', ) _DEVICES_KEYS = ( ID, INTERFACE_NAME, ) = ( 'id', 'interface_name', ) _CONNECTIONS_KEYS = ( NETWORK_ID, SEGMENTATION_TYPE, SEGMENTATION_ID, ) = ( 'network_id', 'segmentation_type', 'segmentation_id', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, description=_('The name of the network gateway.'), update_allowed=True ), DEVICES: properties.Schema( properties.Schema.LIST, description=_('Device info for this network gateway.'), required=True, constraints=[constraints.Length(min=1)], update_allowed=True, schema=properties.Schema( properties.Schema.MAP, schema={ ID: properties.Schema( properties.Schema.STRING, description=_('The device id for the network ' 'gateway.'), required=True ), INTERFACE_NAME: properties.Schema( properties.Schema.STRING, description=_('The interface name for the ' 'network gateway.'), required=True ) } ) ), CONNECTIONS: properties.Schema( properties.Schema.LIST, description=_('Connection info for this network gateway.'), default={}, update_allowed=True, schema=properties.Schema( properties.Schema.MAP, schema={ NETWORK_ID: properties.Schema( properties.Schema.STRING, description=_( 'The id of internal network to connect on ' 'the network gateway.'), required=True ), SEGMENTATION_TYPE: properties.Schema( properties.Schema.STRING, description=_( 'L2 segmentation strategy on the external ' 'side of the network gateway.'), default='flat', constraints=[constraints.AllowedValues( ('flat', 'vlan'))] ), SEGMENTATION_ID: properties.Schema( properties.Schema.INTEGER, description=_( 'The id for L2 segment on the external side ' 'of the network gateway. Must be specified ' 'when using vlan.'), constraints=[constraints.Range(0, 4094)] ) } ) ) } attributes_schema = { "default": _("A boolean value of default flag."), "show": _("All attributes.") } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_network_gateway( self.resource_id)['network_gateway'] def validate(self): ''' Validate any of the provided params ''' super(NetworkGateway, self).validate() connections = self.properties[self.CONNECTIONS] for connection in connections: segmentation_type = connection[self.SEGMENTATION_TYPE] segmentation_id = connection.get(self.SEGMENTATION_ID) if segmentation_type == 'vlan' and segmentation_id is None: msg = _("segmentation_id must be specified for using vlan") raise exception.StackValidationFailed(message=msg) if segmentation_type == 'flat' and segmentation_id: msg = _( "segmentation_id cannot be specified except 0 for " "using flat") raise exception.StackValidationFailed(message=msg) def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) connections = props.pop(self.CONNECTIONS) ret = self.neutron().create_network_gateway( {'network_gateway': props})['network_gateway'] for connection in connections: self.neutron().connect_network_gateway( ret['id'], connection ) self.resource_id_set(ret['id']) def handle_delete(self): if not self.resource_id: return client = self.neutron() connections = self.properties[self.CONNECTIONS] for connection in connections: try: client.disconnect_network_gateway( self.resource_id, connection ) except NeutronClientException as ex: self._handle_not_found_exception(ex) try: client.delete_network_gateway(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def handle_update(self, json_snippet, tmpl_diff, prop_diff): props = self.prepare_update_properties(json_snippet) connections = props.pop(self.CONNECTIONS) if self.DEVICES in prop_diff: self.handle_delete() self.properties.data.update(props) self.handle_create() return else: props.pop(self.DEVICES, None) if self.NAME in prop_diff: self.neutron().update_network_gateway( self.resource_id, {'network_gateway': props}) if self.CONNECTIONS in prop_diff: for connection in self.properties[self.CONNECTIONS]: try: self.neutron().disconnect_network_gateway( self.resource_id, connection ) except NeutronClientException as ex: self._handle_not_found_exception(ex) for connection in connections: self.neutron().connect_network_gateway( self.resource_id, connection ) def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::NetworkGateway': NetworkGateway, } heat-2014.1.5/heat/engine/resources/neutron/floatingip.py0000664000567000056700000001267212540642614024441 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. from heat.engine import clients from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.engine.resources.neutron import router from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException logger = logging.getLogger(__name__) class FloatingIP(neutron.NeutronResource): PROPERTIES = ( FLOATING_NETWORK_ID, VALUE_SPECS, PORT_ID, FIXED_IP_ADDRESS, ) = ( 'floating_network_id', 'value_specs', 'port_id', 'fixed_ip_address', ) properties_schema = { FLOATING_NETWORK_ID: properties.Schema( properties.Schema.STRING, _('ID of network to allocate floating IP from.'), required=True ), VALUE_SPECS: properties.Schema( properties.Schema.MAP, _('Extra parameters to include in the "floatingip" object in the ' 'creation request. Parameters are often specific to installed ' 'hardware or extensions.'), default={} ), PORT_ID: properties.Schema( properties.Schema.STRING, _('ID of an existing port with at least one IP address to ' 'associate with this floating IP.') ), FIXED_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('IP address to use if the port has multiple addresses.') ), } attributes_schema = { 'router_id': _('ID of the router used as gateway, set when associated ' 'with a port.'), 'tenant_id': _('The tenant owning this floating IP.'), 'floating_network_id': _('ID of the network in which this IP is ' 'allocated.'), 'fixed_ip_address': _('IP address of the associated port, if ' 'specified.'), 'floating_ip_address': _('The allocated address of this IP.'), 'port_id': _('ID of the port associated with this IP.'), 'show': _('All attributes.') } def add_dependencies(self, deps): super(FloatingIP, self).add_dependencies(deps) # depend on any RouterGateway in this template with the same # network_id as this floating_network_id for resource in self.stack.itervalues(): if (resource.has_interface('OS::Neutron::RouterGateway') and resource.properties.get(router.RouterGateway.NETWORK_ID) == self.properties.get(self.FLOATING_NETWORK_ID)): deps += (self, resource) def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) fip = self.neutron().create_floatingip({ 'floatingip': props})['floatingip'] self.resource_id_set(fip['id']) def _show_resource(self): return self.neutron().show_floatingip(self.resource_id)['floatingip'] def handle_delete(self): client = self.neutron() try: client.delete_floatingip(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) class FloatingIPAssociation(neutron.NeutronResource): PROPERTIES = ( FLOATINGIP_ID, PORT_ID, FIXED_IP_ADDRESS, ) = ( 'floatingip_id', 'port_id', 'fixed_ip_address', ) properties_schema = { FLOATINGIP_ID: properties.Schema( properties.Schema.STRING, _('ID of the floating IP to associate.'), required=True ), PORT_ID: properties.Schema( properties.Schema.STRING, _('ID of an existing port with at least one IP address to ' 'associate with this floating IP.') ), FIXED_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('IP address to use if the port has multiple addresses.') ), } def handle_create(self): props = self.prepare_properties(self.properties, self.name) floatingip_id = props.pop(self.FLOATINGIP_ID) self.neutron().update_floatingip(floatingip_id, { 'floatingip': props})['floatingip'] self.resource_id_set('%s:%s' % (floatingip_id, props[self.PORT_ID])) def handle_delete(self): if not self.resource_id: return client = self.neutron() (floatingip_id, port_id) = self.resource_id.split(':') try: client.update_floatingip( floatingip_id, {'floatingip': {'port_id': None}}) except NeutronClientException as ex: self._handle_not_found_exception(ex) def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::FloatingIP': FloatingIP, 'OS::Neutron::FloatingIPAssociation': FloatingIPAssociation, } heat-2014.1.5/heat/engine/resources/neutron/firewall.py0000664000567000056700000002712712540642614024113 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. from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException logger = logging.getLogger(__name__) class Firewall(neutron.NeutronResource): """ A resource for the Firewall resource in Neutron FWaaS. """ PROPERTIES = ( NAME, DESCRIPTION, ADMIN_STATE_UP, FIREWALL_POLICY_ID, ) = ( 'name', 'description', 'admin_state_up', 'firewall_policy_id', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the firewall.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the firewall.'), update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('Administrative state of the firewall. If false (down), ' 'firewall does not forward packets and will drop all ' 'traffic to/from VMs behind the firewall.'), default=True, update_allowed=True ), FIREWALL_POLICY_ID: properties.Schema( properties.Schema.STRING, _('The ID of the firewall policy that this firewall is ' 'associated with.'), required=True, update_allowed=True ), } attributes_schema = { 'name': _('Name for the firewall.'), 'description': _('Description of the firewall.'), 'admin_state_up': _('The administrative state of the firewall.'), 'firewall_policy_id': _('Unique identifier of the firewall policy ' 'used to create the firewall.'), 'status': _('The status of the firewall.'), 'tenant_id': _('Id of the tenant owning the firewall.'), 'show': _('All attributes.'), } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_firewall(self.resource_id)['firewall'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) firewall = self.neutron().create_firewall({'firewall': props})[ 'firewall'] self.resource_id_set(firewall['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_firewall( self.resource_id, {'firewall': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_firewall(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class FirewallPolicy(neutron.NeutronResource): """ A resource for the FirewallPolicy resource in Neutron FWaaS. """ PROPERTIES = ( NAME, DESCRIPTION, SHARED, AUDITED, FIREWALL_RULES, ) = ( 'name', 'description', 'shared', 'audited', 'firewall_rules', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the firewall policy.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the firewall policy.'), update_allowed=True ), SHARED: properties.Schema( properties.Schema.BOOLEAN, _('Whether this policy should be shared across all tenants.'), default=False, update_allowed=True ), AUDITED: properties.Schema( properties.Schema.BOOLEAN, _('Whether this policy should be audited. When set to True, ' 'each time the firewall policy or the associated firewall ' 'rules are changed, this attribute will be set to False and ' 'will have to be explicitly set to True through an update ' 'operation.'), default=False, update_allowed=True ), FIREWALL_RULES: properties.Schema( properties.Schema.LIST, _('An ordered list of firewall rules to apply to the firewall.'), required=True, update_allowed=True ), } attributes_schema = { 'name': _('Name for the firewall policy.'), 'description': _('Description of the firewall policy.'), 'firewall_rules': _('List of firewall rules in this firewall policy.'), 'shared': _('Shared status of this firewall policy.'), 'audited': _('Audit status of this firewall policy.'), 'tenant_id': _('Id of the tenant owning the firewall policy.') } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_firewall_policy(self.resource_id)[ 'firewall_policy'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) firewall_policy = self.neutron().create_firewall_policy( {'firewall_policy': props})['firewall_policy'] self.resource_id_set(firewall_policy['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_firewall_policy( self.resource_id, {'firewall_policy': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_firewall_policy(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class FirewallRule(neutron.NeutronResource): """ A resource for the FirewallRule resource in Neutron FWaaS. """ PROPERTIES = ( NAME, DESCRIPTION, SHARED, PROTOCOL, IP_VERSION, SOURCE_IP_ADDRESS, DESTINATION_IP_ADDRESS, SOURCE_PORT, DESTINATION_PORT, ACTION, ENABLED, ) = ( 'name', 'description', 'shared', 'protocol', 'ip_version', 'source_ip_address', 'destination_ip_address', 'source_port', 'destination_port', 'action', 'enabled', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name for the firewall rule.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the firewall rule.'), update_allowed=True ), SHARED: properties.Schema( properties.Schema.BOOLEAN, _('Whether this rule should be shared across all tenants.'), default=False, update_allowed=True ), PROTOCOL: properties.Schema( properties.Schema.STRING, _('Protocol for the firewall rule.'), constraints=[ constraints.AllowedValues(['tcp', 'udp', 'icmp', None]), ], update_allowed=True ), IP_VERSION: properties.Schema( properties.Schema.STRING, _('Internet protocol version.'), default='4', constraints=[ constraints.AllowedValues(['4', '6']), ], update_allowed=True ), SOURCE_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('Source IP address or CIDR.'), update_allowed=True ), DESTINATION_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('Destination IP address or CIDR.'), update_allowed=True ), SOURCE_PORT: properties.Schema( properties.Schema.STRING, _('Source port number or a range.'), update_allowed=True ), DESTINATION_PORT: properties.Schema( properties.Schema.STRING, _('Destination port number or a range.'), update_allowed=True ), ACTION: properties.Schema( properties.Schema.STRING, _('Action to be performed on the traffic matching the rule.'), default='deny', constraints=[ constraints.AllowedValues(['allow', 'deny']), ], update_allowed=True ), ENABLED: properties.Schema( properties.Schema.BOOLEAN, _('Whether this rule should be enabled.'), default=True, update_allowed=True ), } attributes_schema = { 'name': _('Name for the firewall rule.'), 'description': _('Description of the firewall rule.'), 'firewall_policy_id': _('Unique identifier of the firewall policy to ' 'which this firewall rule belongs.'), 'shared': _('Shared status of this firewall rule.'), 'protocol': _('Protocol value for this firewall rule.'), 'ip_version': _('Ip_version for this firewall rule.'), 'source_ip_address': _('Source ip_address for this firewall rule.'), 'destination_ip_address': _('Destination ip_address for this ' 'firewall rule.'), 'source_port': _('Source port range for this firewall rule.'), 'destination_port': _('Destination port range for this firewall ' 'rule.'), 'action': _('Allow or deny action for this firewall rule.'), 'enabled': _('Indicates whether this firewall rule is enabled or ' 'not.'), 'position': _('Position of the rule within the firewall policy.'), 'tenant_id': _('Id of the tenant owning the firewall.') } update_allowed_keys = ('Properties',) def _show_resource(self): return self.neutron().show_firewall_rule( self.resource_id)['firewall_rule'] def handle_create(self): props = self.prepare_properties( self.properties, self.physical_resource_name()) firewall_rule = self.neutron().create_firewall_rule( {'firewall_rule': props})['firewall_rule'] self.resource_id_set(firewall_rule['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_firewall_rule( self.resource_id, {'firewall_rule': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_firewall_rule(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::Firewall': Firewall, 'OS::Neutron::FirewallPolicy': FirewallPolicy, 'OS::Neutron::FirewallRule': FirewallRule, } heat-2014.1.5/heat/engine/resources/neutron/provider_net.py0000664000567000056700000001037712540642614025005 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. from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine.resources.neutron import net class ProviderNet(net.Net): PROPERTIES = ( NAME, PROVIDER_NETWORK_TYPE, PROVIDER_PHYSICAL_NETWORK, PROVIDER_SEGMENTATION_ID, ADMIN_STATE_UP, SHARED, ) = ( 'name', 'network_type', 'physical_network', 'segmentation_id', 'admin_state_up', 'shared', ) properties_schema = { NAME: net.Net.properties_schema[NAME], PROVIDER_NETWORK_TYPE: properties.Schema( properties.Schema.STRING, _('A string specifying the provider network type for the ' 'network.'), update_allowed=True, required=True, constraints=[ constraints.AllowedValues(['vlan', 'flat']), ] ), PROVIDER_PHYSICAL_NETWORK: properties.Schema( properties.Schema.STRING, _('A string specifying physical network mapping for the ' 'network.'), update_allowed=True, required=True, ), PROVIDER_SEGMENTATION_ID: properties.Schema( properties.Schema.STRING, _('A string specifying the segmentation id for the ' 'network.'), update_allowed=True ), ADMIN_STATE_UP: net.Net.properties_schema[ADMIN_STATE_UP], SHARED: properties.Schema( properties.Schema.BOOLEAN, _('Whether this network should be shared across all tenants.'), default=True, update_allowed=True ), } update_allowed_keys = ('Properties',) attributes_schema = { "status": _("The status of the network."), "subnets": _("Subnets of this network."), "show": _("All attributes."), } def validate(self): ''' Validates to ensure that segmentation_id is not there for flat network type. ''' super(ProviderNet, self).validate() if (self.properties.get(self.PROVIDER_SEGMENTATION_ID) and self.properties.get(self.PROVIDER_NETWORK_TYPE) != 'vlan'): msg = _('segmentation_id not allowed for flat network type.') raise exception.StackValidationFailed(message=msg) @staticmethod def add_provider_extension(props, key): props['provider:' + key] = props.pop(key) @staticmethod def prepare_provider_properties(self, props): self.add_provider_extension(props, self.PROVIDER_NETWORK_TYPE) self.add_provider_extension(props, self.PROVIDER_PHYSICAL_NETWORK) if self.PROVIDER_SEGMENTATION_ID in props.keys(): self.add_provider_extension(props, self.PROVIDER_SEGMENTATION_ID) def handle_create(self): ''' Adds 'provider:' extension to the required properties during create. ''' props = self.prepare_properties( self.properties, self.physical_resource_name()) self.prepare_provider_properties(self, props) prov_net = self.neutron().create_network({'network': props})['network'] self.resource_id_set(prov_net['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): ''' Adds 'provider:' extension to the required properties during update. ''' props = self.prepare_update_properties(json_snippet) self.prepare_provider_properties(self, props) self.neutron().update_network(self.resource_id, {'network': props}) def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::ProviderNet': ProviderNet, } heat-2014.1.5/heat/engine/resources/neutron/loadbalancer.py0000664000567000056700000005611012540642614024707 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. from heat.common import exception from heat.db import api as db_api from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources.neutron import neutron from heat.engine.resources import nova_utils from heat.engine import scheduler if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException from neutronclient.neutron import v2_0 as neutronV20 class HealthMonitor(neutron.NeutronResource): """ A resource for managing health monitors for load balancers in Neutron. """ PROPERTIES = ( DELAY, TYPE, MAX_RETRIES, TIMEOUT, ADMIN_STATE_UP, HTTP_METHOD, EXPECTED_CODES, URL_PATH, ) = ( 'delay', 'type', 'max_retries', 'timeout', 'admin_state_up', 'http_method', 'expected_codes', 'url_path', ) properties_schema = { DELAY: properties.Schema( properties.Schema.INTEGER, _('The minimum time in seconds between regular connections of ' 'the member.'), required=True, update_allowed=True ), TYPE: properties.Schema( properties.Schema.STRING, _('One of predefined health monitor types.'), required=True, constraints=[ constraints.AllowedValues(['PING', 'TCP', 'HTTP', 'HTTPS']), ] ), MAX_RETRIES: properties.Schema( properties.Schema.INTEGER, _('Number of permissible connection failures before changing the ' 'member status to INACTIVE.'), required=True, update_allowed=True ), TIMEOUT: properties.Schema( properties.Schema.INTEGER, _('Maximum number of seconds for a monitor to wait for a ' 'connection to be established before it times out.'), required=True, update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('The administrative state of the health monitor.'), default=True, update_allowed=True ), HTTP_METHOD: properties.Schema( properties.Schema.STRING, _('The HTTP method used for requests by the monitor of type ' 'HTTP.'), update_allowed=True ), EXPECTED_CODES: properties.Schema( properties.Schema.STRING, _('The list of HTTP status codes expected in response from the ' 'member to declare it healthy.'), update_allowed=True ), URL_PATH: properties.Schema( properties.Schema.STRING, _('The HTTP path used in the HTTP request used by the monitor to ' 'test a member health.'), update_allowed=True ), } update_allowed_keys = ('Properties',) attributes_schema = { 'admin_state_up': _('The administrative state of this health ' 'monitor.'), 'delay': _('The minimum time in seconds between regular connections ' 'of the member.'), 'expected_codes': _('The list of HTTP status codes expected in ' 'response from the member to declare it healthy.'), 'http_method': _('The HTTP method used for requests by the monitor of ' 'type HTTP.'), 'max_retries': _('Number of permissible connection failures before ' 'changing the member status to INACTIVE.'), 'timeout': _('Maximum number of seconds for a monitor to wait for a ' 'connection to be established before it times out.'), 'type': _('One of predefined health monitor types.'), 'url_path': _('The HTTP path used in the HTTP request used by the ' 'monitor to test a member health.'), 'tenant_id': _('Tenant owning the health monitor.'), 'show': _('All attributes.'), } def handle_create(self): properties = self.prepare_properties( self.properties, self.physical_resource_name()) health_monitor = self.neutron().create_health_monitor( {'health_monitor': properties})['health_monitor'] self.resource_id_set(health_monitor['id']) def _show_resource(self): return self.neutron().show_health_monitor( self.resource_id)['health_monitor'] def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_health_monitor( self.resource_id, {'health_monitor': prop_diff}) def handle_delete(self): try: self.neutron().delete_health_monitor(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class Pool(neutron.NeutronResource): """ A resource for managing load balancer pools in Neutron. """ PROPERTIES = ( PROTOCOL, SUBNET_ID, LB_METHOD, NAME, DESCRIPTION, ADMIN_STATE_UP, VIP, MONITORS, ) = ( 'protocol', 'subnet_id', 'lb_method', 'name', 'description', 'admin_state_up', 'vip', 'monitors', ) _VIP_KEYS = ( VIP_NAME, VIP_DESCRIPTION, VIP_SUBNET, VIP_ADDRESS, VIP_CONNECTION_LIMIT, VIP_PROTOCOL_PORT, VIP_SESSION_PERSISTENCE, VIP_ADMIN_STATE_UP, ) = ( 'name', 'description', 'subnet', 'address', 'connection_limit', 'protocol_port', 'session_persistence', 'admin_state_up', ) _VIP_SESSION_PERSISTENCE_KEYS = ( VIP_SESSION_PERSISTENCE_TYPE, VIP_SESSION_PERSISTENCE_COOKIE_NAME, ) = ( 'type', 'cookie_name', ) properties_schema = { PROTOCOL: properties.Schema( properties.Schema.STRING, _('Protocol for balancing.'), required=True, constraints=[ constraints.AllowedValues(['TCP', 'HTTP', 'HTTPS']), ] ), SUBNET_ID: properties.Schema( properties.Schema.STRING, _('The subnet for the port on which the members ' 'of the pool will be connected.'), required=True ), LB_METHOD: properties.Schema( properties.Schema.STRING, _('The algorithm used to distribute load between the members of ' 'the pool.'), required=True, constraints=[ constraints.AllowedValues(['ROUND_ROBIN', 'LEAST_CONNECTIONS', 'SOURCE_IP']), ], update_allowed=True ), NAME: properties.Schema( properties.Schema.STRING, _('Name of the pool.') ), DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the pool.'), update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('The administrative state of this pool.'), default=True, update_allowed=True ), VIP: properties.Schema( properties.Schema.MAP, _('IP address and port of the pool.'), schema={ VIP_NAME: properties.Schema( properties.Schema.STRING, _('Name of the vip.') ), VIP_DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the vip.') ), VIP_SUBNET: properties.Schema( properties.Schema.STRING, _('Subnet of the vip.') ), VIP_ADDRESS: properties.Schema( properties.Schema.STRING, _('IP address of the vip.') ), VIP_CONNECTION_LIMIT: properties.Schema( properties.Schema.INTEGER, _('The maximum number of connections per second ' 'allowed for the vip.') ), VIP_PROTOCOL_PORT: properties.Schema( properties.Schema.INTEGER, _('TCP port on which to listen for client traffic ' 'that is associated with the vip address.'), required=True ), VIP_SESSION_PERSISTENCE: properties.Schema( properties.Schema.MAP, _('Configuration of session persistence.'), schema={ VIP_SESSION_PERSISTENCE_TYPE: properties.Schema( properties.Schema.STRING, _('Method of implementation of session ' 'persistence feature.'), required=True, constraints=[constraints.AllowedValues( ['SOURCE_IP', 'HTTP_COOKIE', 'APP_COOKIE'] )] ), VIP_SESSION_PERSISTENCE_COOKIE_NAME: properties.Schema( properties.Schema.STRING, _('Name of the cookie, ' 'required if type is APP_COOKIE.') ) } ), VIP_ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('The administrative state of this vip.'), default=True ), }, required=True ), MONITORS: properties.Schema( properties.Schema.LIST, _('List of health monitors associated with the pool.'), default=[], update_allowed=True ), } update_allowed_keys = ('Properties',) attributes_schema = { 'admin_state_up': _('The administrative state of this pool.'), 'name': _('Name of the pool.'), 'protocol': _('Protocol to balance.'), 'subnet_id': _('The subnet for the port on which the members ' 'of the pool will be connected.'), 'lb_method': _('The algorithm used to distribute load between the ' 'members of the pool.'), 'description': _('Description of the pool.'), 'tenant_id': _('Tenant owning the pool.'), 'vip': _('Vip associated with the pool.'), } def validate(self): res = super(Pool, self).validate() if res: return res session_p = self.properties[self.VIP].get(self.VIP_SESSION_PERSISTENCE) if session_p is None: # session persistence is not configured, skip validation return persistence_type = session_p[self.VIP_SESSION_PERSISTENCE_TYPE] if persistence_type == 'APP_COOKIE': if session_p.get(self.VIP_SESSION_PERSISTENCE_COOKIE_NAME): return msg = _('Property cookie_name is required, when ' 'session_persistence type is set to APP_COOKIE.') raise exception.StackValidationFailed(message=msg) def handle_create(self): properties = self.prepare_properties( self.properties, self.physical_resource_name()) vip_properties = properties.pop(self.VIP) monitors = properties.pop(self.MONITORS) client = self.neutron() pool = client.create_pool({'pool': properties})['pool'] self.resource_id_set(pool['id']) for monitor in monitors: client.associate_health_monitor( pool['id'], {'health_monitor': {'id': monitor}}) vip_arguments = self.prepare_properties( vip_properties, '%s.vip' % (self.name,)) session_p = vip_arguments.get(self.VIP_SESSION_PERSISTENCE) if session_p is not None: prepared_props = self.prepare_properties(session_p, None) vip_arguments['session_persistence'] = prepared_props vip_arguments['protocol'] = self.properties[self.PROTOCOL] if vip_arguments.get(self.VIP_SUBNET) is None: vip_arguments['subnet_id'] = self.properties[self.SUBNET_ID] else: vip_arguments[ 'subnet_id'] = neutronV20.find_resourceid_by_name_or_id( self.neutron(), 'subnet', vip_arguments.pop(self.VIP_SUBNET)) vip_arguments['pool_id'] = pool['id'] vip = client.create_vip({'vip': vip_arguments})['vip'] self.metadata = {'vip': vip['id']} def _show_resource(self): return self.neutron().show_pool(self.resource_id)['pool'] def check_create_complete(self, data): attributes = self._show_resource() if attributes['status'] == 'PENDING_CREATE': return False elif attributes['status'] == 'ACTIVE': vip_attributes = self.neutron().show_vip( self.metadata['vip'])['vip'] if vip_attributes['status'] == 'PENDING_CREATE': return False elif vip_attributes['status'] == 'ACTIVE': return True raise exception.Error( _('neutron reported unexpected vip resource[%(name)s] ' 'status[%(status)s]') % {'name': vip_attributes['name'], 'status': vip_attributes['status']}) raise exception.Error( _('neutron reported unexpected pool resource[%(name)s] ' 'status[%(status)s]') % {'name': attributes['name'], 'status': attributes['status']}) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: client = self.neutron() monitors = set(prop_diff.pop(self.MONITORS, [])) if monitors: old_monitors = set(self.properties[self.MONITORS]) for monitor in old_monitors - monitors: client.disassociate_health_monitor(self.resource_id, monitor) for monitor in monitors - old_monitors: client.associate_health_monitor( self.resource_id, {'health_monitor': {'id': monitor}}) if prop_diff: client.update_pool(self.resource_id, {'pool': prop_diff}) def _resolve_attribute(self, name): if name == 'vip': return self.neutron().show_vip(self.metadata['vip'])['vip'] return super(Pool, self)._resolve_attribute(name) def _confirm_vip_delete(self): client = self.neutron() while True: try: yield client.show_vip(self.metadata['vip']) except NeutronClientException as ex: self._handle_not_found_exception(ex) break def handle_delete(self): checkers = [] if self.metadata: try: self.neutron().delete_vip(self.metadata['vip']) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: checkers.append(scheduler.TaskRunner(self._confirm_vip_delete)) try: self.neutron().delete_pool(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: checkers.append(scheduler.TaskRunner(self._confirm_delete)) return checkers def check_delete_complete(self, checkers): '''Push all checkers to completion in list order.''' for checker in checkers: if not checker.started(): checker.start() if not checker.step(): return False return True class PoolMember(neutron.NeutronResource): """ A resource to handle load balancer members. """ PROPERTIES = ( POOL_ID, ADDRESS, PROTOCOL_PORT, WEIGHT, ADMIN_STATE_UP, ) = ( 'pool_id', 'address', 'protocol_port', 'weight', 'admin_state_up', ) properties_schema = { POOL_ID: properties.Schema( properties.Schema.STRING, _('The ID of the load balancing pool.'), required=True, update_allowed=True ), ADDRESS: properties.Schema( properties.Schema.STRING, _('IP address of the pool member on the pool network.'), required=True ), PROTOCOL_PORT: properties.Schema( properties.Schema.INTEGER, _('TCP port on which the pool member listens for requests or ' 'connections.'), required=True, constraints=[ constraints.Range(0, 65535), ] ), WEIGHT: properties.Schema( properties.Schema.INTEGER, _('Weight of pool member in the pool (default to 1).'), constraints=[ constraints.Range(0, 256), ], update_allowed=True ), ADMIN_STATE_UP: properties.Schema( properties.Schema.BOOLEAN, _('The administrative state of the pool member.'), default=True ), } attributes_schema = { 'admin_state_up': _('The administrative state of this pool ' 'member.'), 'tenant_id': _('Tenant owning the pool member.'), 'weight': _('Weight of the pool member in the pool.'), 'address': _('IP address of the pool member.'), 'pool_id': _('The ID of the load balancing pool.'), 'protocol_port': _('TCP port on which the pool member listens for' 'requests or connections.'), 'show': _('All attributes.'), } update_allowed_keys = ('Properties',) def handle_create(self): pool = self.properties[self.POOL_ID] client = self.neutron() protocol_port = self.properties[self.PROTOCOL_PORT] address = self.properties[self.ADDRESS] admin_state_up = self.properties[self.ADMIN_STATE_UP] weight = self.properties.get(self.WEIGHT) params = { 'pool_id': pool, 'address': address, 'protocol_port': protocol_port, 'admin_state_up': admin_state_up } if weight is not None: params['weight'] = weight member = client.create_member({'member': params})['member'] self.resource_id_set(member['id']) def _show_resource(self): return self.neutron().show_member(self.resource_id)['member'] def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.neutron().update_member( self.resource_id, {'member': prop_diff}) def handle_delete(self): client = self.neutron() try: client.delete_member(self.resource_id) except NeutronClientException as ex: self._handle_not_found_exception(ex) else: return self._delete_task() class LoadBalancer(resource.Resource): """ A resource to link a neutron pool with servers. """ PROPERTIES = ( POOL_ID, PROTOCOL_PORT, MEMBERS, ) = ( 'pool_id', 'protocol_port', 'members', ) properties_schema = { POOL_ID: properties.Schema( properties.Schema.STRING, _('The ID of the load balancing pool.'), required=True, update_allowed=True ), PROTOCOL_PORT: properties.Schema( properties.Schema.INTEGER, _('Port number on which the servers are running on the members.'), required=True ), MEMBERS: properties.Schema( properties.Schema.LIST, _('The list of Nova server IDs load balanced.'), default=[], update_allowed=True ), } update_allowed_keys = ('Properties',) def handle_create(self): pool = self.properties[self.POOL_ID] client = self.neutron() nova_client = self.nova() protocol_port = self.properties[self.PROTOCOL_PORT] for member in self.properties.get(self.MEMBERS): address = nova_utils.server_to_ipaddress(nova_client, member) lb_member = client.create_member({ 'member': { 'pool_id': pool, 'address': address, 'protocol_port': protocol_port}})['member'] db_api.resource_data_set(self, member, lb_member['id']) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if self.MEMBERS in prop_diff: members = set(prop_diff[self.MEMBERS]) rd_members = db_api.resource_data_get_all(self) old_members = set(rd_members.keys()) client = self.neutron() for member in old_members - members: member_id = rd_members[member] try: client.delete_member(member_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex db_api.resource_data_delete(self, member) pool = self.properties[self.POOL_ID] nova_client = self.nova() protocol_port = self.properties[self.PROTOCOL_PORT] for member in members - old_members: address = nova_utils.server_to_ipaddress(nova_client, member) lb_member = client.create_member({ 'member': { 'pool_id': pool, 'address': address, 'protocol_port': protocol_port}})['member'] db_api.resource_data_set(self, member, lb_member['id']) def handle_delete(self): client = self.neutron() for member in self.properties.get(self.MEMBERS): try: member_id = db_api.resource_data_get(self, member) client.delete_member(member_id) db_api.resource_data_delete(self, member) except NeutronClientException as ex: if ex.status_code != 404: raise ex except exception.NotFound: pass def resource_mapping(): if clients.neutronclient is None: return {} return { 'OS::Neutron::HealthMonitor': HealthMonitor, 'OS::Neutron::Pool': Pool, 'OS::Neutron::PoolMember': PoolMember, 'OS::Neutron::LoadBalancer': LoadBalancer, } heat-2014.1.5/heat/engine/resources/ceilometer/0000775000567000056700000000000012540643116022357 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/ceilometer/alarm.py0000664000567000056700000002271212540642614024033 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. from ceilometerclient import exc as ceilometerclient_exc from heat.common import exception from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine import watchrule COMMON_PROPERTIES = ( ALARM_ACTIONS, OK_ACTIONS, REPEAT_ACTIONS, INSUFFICIENT_DATA_ACTIONS, DESCRIPTION, ENABLED, ) = ( 'alarm_actions', 'ok_actions', 'repeat_actions', 'insufficient_data_actions', 'description', 'enabled', ) common_properties_schema = { DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the alarm.'), update_allowed=True ), ENABLED: properties.Schema( properties.Schema.BOOLEAN, _('True if alarm evaluation/actioning is enabled.'), default='true', update_allowed=True ), ALARM_ACTIONS: properties.Schema( properties.Schema.LIST, _('A list of URLs (webhooks) to invoke when state transitions to ' 'alarm.'), update_allowed=True ), OK_ACTIONS: properties.Schema( properties.Schema.LIST, _('A list of URLs (webhooks) to invoke when state transitions to ' 'ok.'), update_allowed=True ), INSUFFICIENT_DATA_ACTIONS: properties.Schema( properties.Schema.LIST, _('A list of URLs (webhooks) to invoke when state transitions to ' 'insufficient-data.'), update_allowed=True ), REPEAT_ACTIONS: properties.Schema( properties.Schema.BOOLEAN, _('False to trigger actions when the threshold is reached AND ' 'the alarm\'s state has changed. By default, actions are called ' 'each time the threshold is reached.'), default='true', update_allowed=True ) } def actions_to_urls(stack, properties): kwargs = {} for k, v in iter(properties.items()): if k in [ALARM_ACTIONS, OK_ACTIONS, INSUFFICIENT_DATA_ACTIONS] and v is not None: kwargs[k] = [] for act in v: # if the action is a resource name # we ask the destination resource for an alarm url. # the template writer should really do this in the # template if possible with: # {Fn::GetAtt: ['MyAction', 'AlarmUrl']} if act in stack: url = stack[act].FnGetAtt('AlarmUrl') kwargs[k].append(url) else: kwargs[k].append(act) else: kwargs[k] = v return kwargs class CeilometerAlarm(resource.Resource): PROPERTIES = ( COMPARISON_OPERATOR, EVALUATION_PERIODS, METER_NAME, PERIOD, STATISTIC, THRESHOLD, MATCHING_METADATA, ) = ( 'comparison_operator', 'evaluation_periods', 'meter_name', 'period', 'statistic', 'threshold', 'matching_metadata', ) properties_schema = { COMPARISON_OPERATOR: properties.Schema( properties.Schema.STRING, _('Operator used to compare specified statistic with threshold.'), constraints=[ constraints.AllowedValues(['ge', 'gt', 'eq', 'ne', 'lt', 'le']), ], update_allowed=True ), EVALUATION_PERIODS: properties.Schema( properties.Schema.INTEGER, _('Number of periods to evaluate over.'), update_allowed=True ), METER_NAME: properties.Schema( properties.Schema.STRING, _('Meter name watched by the alarm.'), required=True ), PERIOD: properties.Schema( properties.Schema.INTEGER, _('Period (seconds) to evaluate over.'), update_allowed=True ), STATISTIC: properties.Schema( properties.Schema.STRING, _('Meter statistic to evaluate.'), constraints=[ constraints.AllowedValues(['count', 'avg', 'sum', 'min', 'max']), ], update_allowed=True ), THRESHOLD: properties.Schema( properties.Schema.NUMBER, _('Threshold to evaluate against.'), required=True, update_allowed=True ), MATCHING_METADATA: properties.Schema( properties.Schema.MAP, _('Meter should match this resource metadata (key=value) ' 'additionally to the meter_name.') ), } properties_schema.update(common_properties_schema) update_allowed_keys = ('Properties',) def handle_create(self): props = actions_to_urls(self.stack, self.parsed_template('Properties')) props['name'] = self.physical_resource_name() alarm = self.ceilometer().alarms.create(**props) self.resource_id_set(alarm.alarm_id) # the watchrule below is for backwards compatibility. # 1) so we don't create watch tasks unneccessarly # 2) to support CW stats post, we will redirect the request # to ceilometer. wr = watchrule.WatchRule(context=self.context, watch_name=self.physical_resource_name(), rule=self.parsed_template('Properties'), stack_id=self.stack.id) wr.state = wr.CEILOMETER_CONTROLLED wr.store() def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: kwargs = {'alarm_id': self.resource_id} kwargs.update(prop_diff) alarms_client = self.ceilometer().alarms alarms_client.update(**actions_to_urls(self.stack, kwargs)) def handle_suspend(self): if self.resource_id is not None: self.ceilometer().alarms.update(alarm_id=self.resource_id, enabled=False) def handle_resume(self): if self.resource_id is not None: self.ceilometer().alarms.update(alarm_id=self.resource_id, enabled=True) def handle_delete(self): try: wr = watchrule.WatchRule.load( self.context, watch_name=self.physical_resource_name()) wr.destroy() except exception.WatchRuleNotFound: pass if self.resource_id is not None: try: self.ceilometer().alarms.delete(self.resource_id) except ceilometerclient_exc.HTTPNotFound: pass class CombinationAlarm(resource.Resource): PROPERTIES = ( ALARM_IDS, OPERATOR, ) = ( 'alarm_ids', 'operator', ) properties_schema = { ALARM_IDS: properties.Schema( properties.Schema.LIST, _('List of alarm identifiers to combine.'), required=True, constraints=[constraints.Length(min=1)], update_allowed=True), OPERATOR: properties.Schema( properties.Schema.STRING, _('Operator used to combine the alarms.'), constraints=[constraints.AllowedValues(['and', 'or'])], update_allowed=True) } properties_schema.update(common_properties_schema) update_allowed_keys = ('Properties',) def handle_create(self): properties = actions_to_urls(self.stack, self.parsed_template('Properties')) properties['name'] = self.physical_resource_name() properties['type'] = 'combination' alarm = self.ceilometer().alarms.create( **self._reformat_properties(properties)) self.resource_id_set(alarm.alarm_id) def _reformat_properties(self, properties): combination_rule = {} for name in [self.ALARM_IDS, self.OPERATOR, REPEAT_ACTIONS]: value = properties.pop(name, None) if value: combination_rule[name] = value if combination_rule: properties['combination_rule'] = combination_rule return properties def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: kwargs = {'alarm_id': self.resource_id} kwargs.update(prop_diff) alarms_client = self.ceilometer().alarms alarms_client.update(**self._reformat_properties( actions_to_urls(self.stack, kwargs))) def handle_suspend(self): self.ceilometer().alarms.update( alarm_id=self.resource_id, enabled=False) def handle_resume(self): self.ceilometer().alarms.update( alarm_id=self.resource_id, enabled=True) def handle_delete(self): try: self.ceilometer().alarms.delete(self.resource_id) except ceilometerclient_exc.HTTPNotFound: pass def resource_mapping(): return { 'OS::Ceilometer::Alarm': CeilometerAlarm, 'OS::Ceilometer::CombinationAlarm': CombinationAlarm, } heat-2014.1.5/heat/engine/resources/ceilometer/__init__.py0000664000567000056700000000000012540642614024460 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/resources/network_interface.py0000664000567000056700000001211712540642614024316 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. from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class NetworkInterface(resource.Resource): PROPERTIES = ( DESCRIPTION, GROUP_SET, PRIVATE_IP_ADDRESS, SOURCE_DEST_CHECK, SUBNET_ID, TAGS, ) = ( 'Description', 'GroupSet', 'PrivateIpAddress', 'SourceDestCheck', 'SubnetId', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for this interface.') ), GROUP_SET: properties.Schema( properties.Schema.LIST, _('List of security group IDs associated with this interface.'), default=[] ), PRIVATE_IP_ADDRESS: properties.Schema( properties.Schema.STRING ), SOURCE_DEST_CHECK: properties.Schema( properties.Schema.BOOLEAN, _('Flag indicating if traffic to or from instance is validated.'), implemented=False ), SUBNET_ID: properties.Schema( properties.Schema.STRING, _('Subnet ID to associate with this interface.'), required=True ), TAGS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, _('List of tags associated with this interface.'), schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, implemented=False, ) ), } attributes_schema = {'PrivateIpAddress': _('Private IP address of the ' 'network interface.')} @staticmethod def network_id_from_subnet_id(neutronclient, subnet_id): subnet_info = neutronclient.show_subnet(subnet_id) return subnet_info['subnet']['network_id'] def __init__(self, name, json_snippet, stack): super(NetworkInterface, self).__init__(name, json_snippet, stack) self.fixed_ip_address = None def handle_create(self): client = self.neutron() subnet_id = self.properties[self.SUBNET_ID] network_id = self.network_id_from_subnet_id(client, subnet_id) fixed_ip = {'subnet_id': subnet_id} if self.properties[self.PRIVATE_IP_ADDRESS]: fixed_ip['ip_address'] = self.properties[self.PRIVATE_IP_ADDRESS] props = { 'name': self.physical_resource_name(), 'admin_state_up': True, 'network_id': network_id, 'fixed_ips': [fixed_ip] } if self.properties[self.GROUP_SET]: sgs = neutron.NeutronResource.get_secgroup_uuids( self.properties.get(self.GROUP_SET), self.neutron()) props['security_groups'] = sgs port = client.create_port({'port': props})['port'] self.resource_id_set(port['id']) def handle_delete(self): from neutronclient.common.exceptions import NeutronClientException client = self.neutron() try: client.delete_port(self.resource_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex def _get_fixed_ip_address(self, ): if self.fixed_ip_address is None: from neutronclient.common.exceptions import NeutronClientException client = self.neutron() try: port = client.show_port(self.resource_id)['port'] if port['fixed_ips'] and len(port['fixed_ips']) > 0: self.fixed_ip_address = port['fixed_ips'][0]['ip_address'] except NeutronClientException as ex: if ex.status_code != 404: raise ex return self.fixed_ip_address def _resolve_attribute(self, name): if name == 'PrivateIpAddress': return self._get_fixed_ip_address() def resource_mapping(): if clients.neutronclient is None: return {} return { 'AWS::EC2::NetworkInterface': NetworkInterface, } heat-2014.1.5/heat/engine/resources/eip.py0000664000567000056700000002420212540642614021360 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. from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources.vpc import VPC from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class ElasticIp(resource.Resource): PROPERTIES = ( DOMAIN, INSTANCE_ID, ) = ( 'Domain', 'InstanceId', ) properties_schema = { DOMAIN: properties.Schema( properties.Schema.STRING, _('Set to "vpc" to have IP address allocation associated to your ' 'VPC.'), constraints=[ constraints.AllowedValues(['vpc']), ] ), INSTANCE_ID: properties.Schema( properties.Schema.STRING, _('Instance ID to associate with EIP.') ), } attributes_schema = { 'AllocationId': _('ID that AWS assigns to represent the allocation of' ' the address for use with Amazon VPC. Returned only' ' for VPC elastic IP addresses.') } def __init__(self, name, json_snippet, stack): super(ElasticIp, self).__init__(name, json_snippet, stack) self.ipaddress = None def _ipaddress(self): if self.ipaddress is None and self.resource_id is not None: if self.properties[self.DOMAIN] and clients.neutronclient: ne = clients.neutronclient.exceptions.NeutronClientException try: ips = self.neutron().show_floatingip(self.resource_id) except ne as e: if e.status_code == 404: logger.warn(_("Floating IPs not found: %s") % str(e)) else: self.ipaddress = ips['floatingip']['floating_ip_address'] else: try: ips = self.nova().floating_ips.get(self.resource_id) except clients.novaclient.exceptions.NotFound as ex: logger.warn(_("Floating IPs not found: %s") % str(ex)) else: self.ipaddress = ips.ip return self.ipaddress or '' def handle_create(self): """Allocate a floating IP for the current tenant.""" ips = None if self.properties[self.DOMAIN] and clients.neutronclient: from heat.engine.resources.internet_gateway import InternetGateway ext_net = InternetGateway.get_external_network_id(self.neutron()) props = {'floating_network_id': ext_net} ips = self.neutron().create_floatingip({ 'floatingip': props})['floatingip'] self.ipaddress = ips['floating_ip_address'] self.resource_id_set(ips['id']) logger.info(_('ElasticIp create %s') % str(ips)) else: if self.properties[self.DOMAIN]: raise exception.Error(_('Domain property can not be set on ' 'resource %s without Neutron available') % self.name) try: ips = self.nova().floating_ips.create() except clients.novaclient.exceptions.NotFound: with excutils.save_and_reraise_exception(): msg = _("No default floating IP pool configured. " "Set 'default_floating_pool' in nova.conf.") logger.error(msg) if ips: self.ipaddress = ips.ip self.resource_id_set(ips.id) logger.info(_('ElasticIp create %s') % str(ips)) instance_id = self.properties[self.INSTANCE_ID] if instance_id: server = self.nova().servers.get(instance_id) server.add_floating_ip(self._ipaddress()) def handle_delete(self): instance_id = self.properties[self.INSTANCE_ID] if instance_id: try: server = self.nova().servers.get(instance_id) if server: server.remove_floating_ip(self._ipaddress()) except clients.novaclient.exceptions.NotFound: pass """De-allocate a floating IP.""" if self.resource_id is not None: if self.properties[self.DOMAIN] and clients.neutronclient: ne = clients.neutronclient.exceptions.NeutronClientException try: self.neutron().delete_floatingip(self.resource_id) except ne as e: if e.status_code != 404: raise e else: try: self.nova().floating_ips.delete(self.resource_id) except clients.novaclient.exceptions.NotFound: pass def FnGetRefId(self): return unicode(self._ipaddress()) def _resolve_attribute(self, name): if name == 'AllocationId': return unicode(self.resource_id) class ElasticIpAssociation(resource.Resource): PROPERTIES = ( INSTANCE_ID, EIP, ALLOCATION_ID, NETWORK_INTERFACE_ID, ) = ( 'InstanceId', 'EIP', 'AllocationId', 'NetworkInterfaceId', ) properties_schema = { INSTANCE_ID: properties.Schema( properties.Schema.STRING, _('Instance ID to associate with EIP specified by EIP property.') ), EIP: properties.Schema( properties.Schema.STRING, _('EIP address to associate with instance.') ), ALLOCATION_ID: properties.Schema( properties.Schema.STRING, _('Allocation ID for VPC EIP address.') ), NETWORK_INTERFACE_ID: properties.Schema( properties.Schema.STRING, _('Network interface ID to associate with EIP.') ), } def FnGetRefId(self): return unicode(self.physical_resource_name()) def handle_create(self): """Add a floating IP address to a server.""" if self.properties[self.EIP] is not None \ and self.properties[self.ALLOCATION_ID] is not None: raise exception.ResourcePropertyConflict( self.EIP, self.ALLOCATION_ID) if self.properties[self.EIP]: if not self.properties[self.INSTANCE_ID]: logger.warn(_('Skipping association, InstanceId not ' 'specified')) return server = self.nova().servers.get(self.properties[self.INSTANCE_ID]) server.add_floating_ip(self.properties[self.EIP]) self.resource_id_set(self.properties[self.EIP]) logger.debug(_('ElasticIpAssociation ' '%(instance)s.add_floating_ip(%(eip)s)'), {'instance': self.properties[self.INSTANCE_ID], 'eip': self.properties[self.EIP]}) elif self.properties[self.ALLOCATION_ID]: assert clients.neutronclient, "Neutron required for VPC operations" port_id = None port_rsrc = None if self.properties[self.NETWORK_INTERFACE_ID]: port_id = self.properties[self.NETWORK_INTERFACE_ID] port_rsrc = self.neutron().list_ports(id=port_id)['ports'][0] elif self.properties[self.INSTANCE_ID]: instance_id = self.properties[self.INSTANCE_ID] ports = self.neutron().list_ports(device_id=instance_id) port_rsrc = ports['ports'][0] port_id = port_rsrc['id'] else: logger.warn(_('Skipping association, resource not specified')) return float_id = self.properties[self.ALLOCATION_ID] self.resource_id_set(float_id) # assuming only one fixed_ip subnet_id = port_rsrc['fixed_ips'][0]['subnet_id'] subnets = self.neutron().list_subnets(id=subnet_id) subnet_rsrc = subnets['subnets'][0] netid = subnet_rsrc['network_id'] router = VPC.router_for_vpc(self.neutron(), netid) if router is not None: floatingip = self.neutron().show_floatingip(float_id) floating_net_id = \ floatingip['floatingip']['floating_network_id'] self.neutron().add_gateway_router( router['id'], {'network_id': floating_net_id}) self.neutron().update_floatingip( float_id, {'floatingip': {'port_id': port_id}}) def handle_delete(self): """Remove a floating IP address from a server or port.""" if self.properties[self.EIP]: try: instance_id = self.properties[self.INSTANCE_ID] server = self.nova().servers.get(instance_id) if server: server.remove_floating_ip(self.properties[self.EIP]) except clients.novaclient.exceptions.NotFound: pass elif self.properties[self.ALLOCATION_ID]: float_id = self.properties[self.ALLOCATION_ID] ne = clients.neutronclient.exceptions.NeutronClientException try: self.neutron().update_floatingip( float_id, {'floatingip': {'port_id': None}}) except ne as e: if e.status_code != 404: raise e def resource_mapping(): return { 'AWS::EC2::EIP': ElasticIp, 'AWS::EC2::EIPAssociation': ElasticIpAssociation, } heat-2014.1.5/heat/engine/resources/s3.py0000664000567000056700000001372512540642614021140 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. from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils logger = logging.getLogger(__name__) class S3Bucket(resource.Resource): PROPERTIES = ( ACCESS_CONTROL, WEBSITE_CONFIGURATION, TAGS, ) = ( 'AccessControl', 'WebsiteConfiguration', 'Tags', ) _WEBSITE_CONFIGURATION_KEYS = ( WEBSITE_CONFIGURATION_INDEX_DOCUMENT, WEBSITE_CONFIGURATION_ERROR_DOCUMENT, ) = ( 'IndexDocument', 'ErrorDocument', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { ACCESS_CONTROL: properties.Schema( properties.Schema.STRING, _('A predefined access control list (ACL) that grants ' 'permissions on the bucket.'), constraints=[ constraints.AllowedValues(['Private', 'PublicRead', 'PublicReadWrite', 'AuthenticatedRead', 'BucketOwnerRead', 'BucketOwnerFullControl']), ] ), WEBSITE_CONFIGURATION: properties.Schema( properties.Schema.MAP, _('Information used to configure the bucket as a static website.'), schema={ WEBSITE_CONFIGURATION_INDEX_DOCUMENT: properties.Schema( properties.Schema.STRING, _('The name of the index document.') ), WEBSITE_CONFIGURATION_ERROR_DOCUMENT: properties.Schema( properties.Schema.STRING, _('The name of the error document.') ), } ), TAGS: properties.Schema( properties.Schema.LIST, _('Tags to attach to the bucket.'), schema=properties.Schema( properties.Schema.MAP, schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, _('The tag key name.'), required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, _('The tag value.'), required=True ), }, ) ), } attributes_schema = { 'DomainName': _('The DNS name of the specified bucket.'), 'WebsiteURL': _('The website endpoint for the specified bucket.') } def tags_to_headers(self): if self.properties[self.TAGS] is None: return {} return dict( ('X-Container-Meta-S3-Tag-' + tm[self.TAG_KEY], tm[self.TAG_VALUE]) for tm in self.properties[self.TAGS]) def handle_create(self): """Create a bucket.""" container = self.physical_resource_name() headers = self.tags_to_headers() logger.debug(_('S3Bucket create container %(container)s with headers ' '%(headers)s') % { 'container': container, 'headers': headers}) if self.properties[self.WEBSITE_CONFIGURATION] is not None: sc = self.properties[self.WEBSITE_CONFIGURATION] index_doc = sc[self.WEBSITE_CONFIGURATION_INDEX_DOCUMENT] error_doc = sc[self.WEBSITE_CONFIGURATION_ERROR_DOCUMENT] # we will assume that swift is configured for the staticweb # wsgi middleware headers['X-Container-Meta-Web-Index'] = index_doc headers['X-Container-Meta-Web-Error'] = error_doc con = self.context ac = self.properties[self.ACCESS_CONTROL] tenant_username = '%s:%s' % (con.tenant, con.username) if ac in ('PublicRead', 'PublicReadWrite'): headers['X-Container-Read'] = '.r:*' elif ac == 'AuthenticatedRead': headers['X-Container-Read'] = con.tenant else: headers['X-Container-Read'] = tenant_username if ac == 'PublicReadWrite': headers['X-Container-Write'] = '.r:*' else: headers['X-Container-Write'] = tenant_username self.swift().put_container(container, headers) self.resource_id_set(container) def handle_delete(self): """Perform specified delete policy.""" logger.debug(_('S3Bucket delete container %s') % self.resource_id) if self.resource_id is not None: try: self.swift().delete_container(self.resource_id) except clients.swiftclient.ClientException as ex: logger.warn(_("Delete container failed: %s") % str(ex)) def FnGetRefId(self): return unicode(self.resource_id) def _resolve_attribute(self, name): url = self.swift().get_auth()[0] parsed = list(urlutils.urlparse(url)) if name == 'DomainName': return parsed[1].split(':')[0] elif name == 'WebsiteURL': return '%s://%s%s/%s' % (parsed[0], parsed[1], parsed[2], self.resource_id) def resource_mapping(): if clients.swiftclient is None: return {} return { 'AWS::S3::Bucket': S3Bucket, } heat-2014.1.5/heat/engine/resources/route_table.py0000664000567000056700000001351312540642614023113 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. from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.engine.resources.neutron import neutron from heat.engine.resources.vpc import VPC from heat.openstack.common import log as logging if clients.neutronclient is not None: from neutronclient.common.exceptions import NeutronClientException logger = logging.getLogger(__name__) class RouteTable(resource.Resource): PROPERTIES = ( VPC_ID, TAGS, ) = ( 'VpcId', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { VPC_ID: properties.Schema( properties.Schema.STRING, _('VPC ID for where the route table is created.'), required=True ), TAGS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, _('List of tags to be attached to this resource.'), schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, implemented=False, ) ), } def handle_create(self): client = self.neutron() props = {'name': self.physical_resource_name()} router = client.create_router({'router': props})['router'] self.resource_id_set(router['id']) def check_create_complete(self, *args): client = self.neutron() attributes = client.show_router( self.resource_id)['router'] if not neutron.NeutronResource.is_built(attributes): return False network_id = self.properties.get(self.VPC_ID) default_router = VPC.router_for_vpc(client, network_id) if default_router and default_router.get('external_gateway_info'): # the default router for the VPC is connected # to the external router, so do it for this too. external_network_id = default_router[ 'external_gateway_info']['network_id'] client.add_gateway_router(self.resource_id, { 'network_id': external_network_id}) return True def handle_delete(self): client = self.neutron() router_id = self.resource_id try: client.delete_router(router_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex # just in case this router has been added to a gateway, remove it try: client.remove_gateway_router(router_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex class SubnetRouteTableAssociation(resource.Resource): PROPERTIES = ( ROUTE_TABLE_ID, SUBNET_ID, ) = ( 'RouteTableId', 'SubnetId', ) properties_schema = { ROUTE_TABLE_ID: properties.Schema( properties.Schema.STRING, _('Route table ID.'), required=True ), SUBNET_ID: properties.Schema( properties.Schema.STRING, _('Subnet ID.'), required=True ), } def handle_create(self): client = self.neutron() subnet_id = self.properties.get(self.SUBNET_ID) router_id = self.properties.get(self.ROUTE_TABLE_ID) #remove the default router association for this subnet. try: previous_router = self._router_for_subnet(subnet_id) if previous_router: client.remove_interface_router( previous_router['id'], {'subnet_id': subnet_id}) except NeutronClientException as ex: if ex.status_code != 404: raise ex client.add_interface_router( router_id, {'subnet_id': subnet_id}) def _router_for_subnet(self, subnet_id): client = self.neutron() subnet = client.show_subnet( subnet_id)['subnet'] network_id = subnet['network_id'] return VPC.router_for_vpc(client, network_id) def handle_delete(self): client = self.neutron() subnet_id = self.properties.get(self.SUBNET_ID) router_id = self.properties.get(self.ROUTE_TABLE_ID) try: client.remove_interface_router(router_id, { 'subnet_id': subnet_id}) except NeutronClientException as ex: if ex.status_code != 404: raise ex # add back the default router try: default_router = self._router_for_subnet(subnet_id) if default_router: client.add_interface_router( default_router['id'], {'subnet_id': subnet_id}) except NeutronClientException as ex: if ex.status_code != 404: raise ex def resource_mapping(): if clients.neutronclient is None: return {} return { 'AWS::EC2::RouteTable': RouteTable, 'AWS::EC2::SubnetRouteTableAssociation': SubnetRouteTableAssociation, } heat-2014.1.5/heat/engine/resources/server.py0000664000567000056700000012602012540642614022112 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. import copy from oslo.config import cfg import uuid from heat.common import exception from heat.db import api as db_api from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources.neutron import subnet from heat.engine.resources import nova_utils from heat.engine.resources.software_config import software_config as sc from heat.engine import scheduler from heat.engine import stack_user from heat.engine import support from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging from heat.openstack.common import uuidutils cfg.CONF.import_opt('instance_user', 'heat.common.config') logger = logging.getLogger(__name__) class Server(stack_user.StackUser): PROPERTIES = ( NAME, IMAGE, BLOCK_DEVICE_MAPPING, FLAVOR, FLAVOR_UPDATE_POLICY, IMAGE_UPDATE_POLICY, KEY_NAME, ADMIN_USER, AVAILABILITY_ZONE, SECURITY_GROUPS, NETWORKS, SCHEDULER_HINTS, METADATA, USER_DATA_FORMAT, USER_DATA, RESERVATION_ID, CONFIG_DRIVE, DISK_CONFIG, PERSONALITY, ADMIN_PASS, SOFTWARE_CONFIG_TRANSPORT ) = ( 'name', 'image', 'block_device_mapping', 'flavor', 'flavor_update_policy', 'image_update_policy', 'key_name', 'admin_user', 'availability_zone', 'security_groups', 'networks', 'scheduler_hints', 'metadata', 'user_data_format', 'user_data', 'reservation_id', 'config_drive', 'diskConfig', 'personality', 'admin_pass', 'software_config_transport' ) _BLOCK_DEVICE_MAPPING_KEYS = ( BLOCK_DEVICE_MAPPING_DEVICE_NAME, BLOCK_DEVICE_MAPPING_VOLUME_ID, BLOCK_DEVICE_MAPPING_SNAPSHOT_ID, BLOCK_DEVICE_MAPPING_VOLUME_SIZE, BLOCK_DEVICE_MAPPING_DELETE_ON_TERM, ) = ( 'device_name', 'volume_id', 'snapshot_id', 'volume_size', 'delete_on_termination', ) _NETWORK_KEYS = ( NETWORK_UUID, NETWORK_ID, NETWORK_FIXED_IP, NETWORK_PORT, ) = ( 'uuid', 'network', 'fixed_ip', 'port', ) _SOFTWARE_CONFIG_FORMATS = ( HEAT_CFNTOOLS, RAW, SOFTWARE_CONFIG ) = ( 'HEAT_CFNTOOLS', 'RAW', 'SOFTWARE_CONFIG' ) _SOFTWARE_CONFIG_TRANSPORTS = ( POLL_SERVER_CFN, POLL_SERVER_HEAT ) = ( 'POLL_SERVER_CFN', 'POLL_SERVER_HEAT' ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Server name.'), update_allowed=True ), IMAGE: properties.Schema( properties.Schema.STRING, _('The ID or name of the image to boot with.'), constraints=[ constraints.CustomConstraint('glance.image') ], update_allowed=True ), BLOCK_DEVICE_MAPPING: properties.Schema( properties.Schema.LIST, _('Block device mappings for this server.'), schema=properties.Schema( properties.Schema.MAP, schema={ BLOCK_DEVICE_MAPPING_DEVICE_NAME: properties.Schema( properties.Schema.STRING, _('A device name where the volume will be ' 'attached in the system at /dev/device_name. ' 'This value is typically vda.'), required=True ), BLOCK_DEVICE_MAPPING_VOLUME_ID: properties.Schema( properties.Schema.STRING, _('The ID of the volume to boot from. Only one ' 'of volume_id or snapshot_id should be ' 'provided.') ), BLOCK_DEVICE_MAPPING_SNAPSHOT_ID: properties.Schema( properties.Schema.STRING, _('The ID of the snapshot to create a volume ' 'from.') ), BLOCK_DEVICE_MAPPING_VOLUME_SIZE: properties.Schema( properties.Schema.INTEGER, _('The size of the volume, in GB. It is safe to ' 'leave this blank and have the Compute service ' 'infer the size.') ), BLOCK_DEVICE_MAPPING_DELETE_ON_TERM: properties.Schema( properties.Schema.BOOLEAN, _('Indicate whether the volume should be deleted ' 'when the server is terminated.') ), }, ) ), FLAVOR: properties.Schema( properties.Schema.STRING, _('The ID or name of the flavor to boot onto.'), required=True, update_allowed=True ), FLAVOR_UPDATE_POLICY: properties.Schema( properties.Schema.STRING, _('Policy on how to apply a flavor update; either by requesting ' 'a server resize or by replacing the entire server.'), default='RESIZE', constraints=[ constraints.AllowedValues(['RESIZE', 'REPLACE']), ], update_allowed=True ), IMAGE_UPDATE_POLICY: properties.Schema( properties.Schema.STRING, _('Policy on how to apply an image-id update; either by ' 'requesting a server rebuild or by replacing the entire server'), default='REPLACE', constraints=[ constraints.AllowedValues(['REBUILD', 'REPLACE', 'REBUILD_PRESERVE_EPHEMERAL']), ], update_allowed=True ), KEY_NAME: properties.Schema( properties.Schema.STRING, _('Name of keypair to inject into the server.'), constraints=[ constraints.CustomConstraint('nova.keypair') ] ), ADMIN_USER: properties.Schema( properties.Schema.STRING, _('Name of the administrative user to use on the server. ' 'This property will be removed from Juno in favor of the ' 'default cloud-init user set up for each image (e.g. "ubuntu" ' 'for Ubuntu 12.04+, "fedora" for Fedora 19+ and "cloud-user" ' 'for CentOS/RHEL 6.5).'), support_status=support.SupportStatus(status=support.DEPRECATED) ), AVAILABILITY_ZONE: properties.Schema( properties.Schema.STRING, _('Name of the availability zone for server placement.') ), SECURITY_GROUPS: properties.Schema( properties.Schema.LIST, _('List of security group names or IDs. Cannot be used if ' 'neutron ports are associated with this server; assign ' 'security groups to the ports instead.'), default=[] ), NETWORKS: properties.Schema( properties.Schema.LIST, _('An ordered list of nics to be added to this server, with ' 'information about connected networks, fixed ips, port etc.'), schema=properties.Schema( properties.Schema.MAP, schema={ NETWORK_UUID: properties.Schema( properties.Schema.STRING, _('ID of network to create a port on.'), support_status=support.SupportStatus( support.DEPRECATED, _('Use property %s.') % NETWORK_ID) ), NETWORK_ID: properties.Schema( properties.Schema.STRING, _('Name or ID of network to create a port on.') ), NETWORK_FIXED_IP: properties.Schema( properties.Schema.STRING, _('Fixed IP address to specify for the port ' 'created on the requested network.') ), NETWORK_PORT: properties.Schema( properties.Schema.STRING, _('ID of an existing port to associate with this ' 'server.') ), }, ), update_allowed=True ), SCHEDULER_HINTS: properties.Schema( properties.Schema.MAP, _('Arbitrary key-value pairs specified by the client to help ' 'boot a server.') ), METADATA: properties.Schema( properties.Schema.MAP, _('Arbitrary key/value metadata to store for this server. Both ' 'keys and values must be 255 characters or less. Non-string ' 'values will be serialized to JSON (and the serialized ' 'string must be 255 characters or less).'), update_allowed=True ), USER_DATA_FORMAT: properties.Schema( properties.Schema.STRING, _('How the user_data should be formatted for the server. For ' 'HEAT_CFNTOOLS, the user_data is bundled as part of the ' 'heat-cfntools cloud-init boot configuration data. For RAW ' 'the user_data is passed to Nova unmodified. ' 'For SOFTWARE_CONFIG user_data is bundled as part of the ' 'software config data, and metadata is derived from any ' 'associated SoftwareDeployment resources.'), default=HEAT_CFNTOOLS, constraints=[ constraints.AllowedValues(_SOFTWARE_CONFIG_FORMATS), ] ), SOFTWARE_CONFIG_TRANSPORT: properties.Schema( properties.Schema.STRING, _('How the server should receive the metadata required for ' 'software configuration. POLL_SERVER_CFN will allow calls to ' 'the cfn API action DescribeStackResource authenticated with ' 'the provided keypair. POLL_SERVER_HEAT will allow calls to ' 'the Heat API resource-show using the provided keystone ' 'credentials.'), default=POLL_SERVER_CFN, constraints=[ constraints.AllowedValues(_SOFTWARE_CONFIG_TRANSPORTS), ] ), USER_DATA: properties.Schema( properties.Schema.STRING, _('User data script to be executed by cloud-init.'), default='' ), RESERVATION_ID: properties.Schema( properties.Schema.STRING, _('A UUID for the set of servers being requested.') ), CONFIG_DRIVE: properties.Schema( properties.Schema.STRING, _('value for config drive either boolean, or volume-id.') ), DISK_CONFIG: properties.Schema( properties.Schema.STRING, _('Control how the disk is partitioned when the server is ' 'created.'), constraints=[ constraints.AllowedValues(['AUTO', 'MANUAL']), ] ), PERSONALITY: properties.Schema( properties.Schema.MAP, _('A map of files to create/overwrite on the server upon boot. ' 'Keys are file names and values are the file contents.'), default={} ), ADMIN_PASS: properties.Schema( properties.Schema.STRING, _('The administrator password for the server.'), required=False, update_allowed=True ), } attributes_schema = { 'show': _('A dict of all server details as returned by the API.'), 'addresses': _('A dict of all network addresses with corresponding' 'port_id.'), 'networks': _('A dict of assigned network addresses of the form: ' '{"public": [ip1, ip2...], "private": [ip3, ip4]}.'), 'first_address': _('Convenience attribute to fetch the first ' 'assigned network address, or an ' 'empty string if nothing has been assigned ' 'at this time. Result may not be predictable ' 'if the server has addresses from more than one ' 'network.'), 'instance_name': _('AWS compatible instance name.'), 'accessIPv4': _('The manually assigned alternative public IPv4 ' 'address of the server.'), 'accessIPv6': _('The manually assigned alternative public IPv6 ' 'address of the server.'), } update_allowed_keys = ('Metadata', 'Properties') # Server host name limit to 53 characters by due to typical default # linux HOST_NAME_MAX of 64, minus the .novalocal appended to the name physical_resource_name_limit = 53 def __init__(self, name, json_snippet, stack): super(Server, self).__init__(name, json_snippet, stack) if self.user_data_software_config(): self._register_access_key() def physical_resource_name(self): name = self.properties.get(self.NAME) if name: return name return super(Server, self).physical_resource_name() def _personality(self): # This method is overridden by the derived CloudServer resource return self.properties.get(self.PERSONALITY) def _key_name(self): # This method is overridden by the derived CloudServer resource return self.properties.get(self.KEY_NAME) @staticmethod def _get_deployments_metadata(heatclient, server_id): return heatclient.software_deployments.metadata( server_id=server_id) def _build_deployments_metadata(self): meta = {} if self.transport_poll_server_heat(): meta['os-collect-config'] = {'heat': { 'user_id': self._get_user_id(), 'password': self.password, 'auth_url': self.context.auth_url, 'project_id': self.stack.stack_user_project_id, 'stack_id': self.stack.identifier().stack_path(), 'resource_name': self.name} } elif self.transport_poll_server_cfn(): meta['os-collect-config'] = {'cfn': { 'metadata_url': '%s/v1/' % cfg.CONF.heat_metadata_server_url, 'access_key_id': self.access_key, 'secret_access_key': self.secret_key, 'stack_name': self.stack.name, 'path': '%s.Metadata' % self.name} } deployments = [] # cannot query the deployments if the nova server does # not exist yet if self.resource_id: deployments = self._get_deployments_metadata( self.heat(), self.resource_id) meta['deployments'] = deployments return meta def _register_access_key(self): ''' Access is limited to this resource, which created the keypair ''' def access_allowed(resource_name): return resource_name == self.name if self.transport_poll_server_cfn(): self.stack.register_access_allowed_handler( self.access_key, access_allowed) elif self.transport_poll_server_heat(): self.stack.register_access_allowed_handler( self._get_user_id(), access_allowed) def _create_transport_credentials(self): if self.transport_poll_server_cfn(): self._create_user() self._create_keypair() elif self.transport_poll_server_heat(): self.password = uuid.uuid4().hex self._create_user() self._register_access_key() @property def access_key(self): try: return db_api.resource_data_get(self, 'access_key') except exception.NotFound: pass @property def secret_key(self): try: return db_api.resource_data_get(self, 'secret_key') except exception.NotFound: pass @property def password(self): try: return db_api.resource_data_get(self, 'password') except exception.NotFound: pass @password.setter def password(self, password): try: if password is None: db_api.resource_data_delete(self, 'password') else: db_api.resource_data_set(self, 'password', password, True) except exception.NotFound: pass @property def metadata(self): if self.user_data_software_config(): return self._build_deployments_metadata() else: return self._metadata @metadata.setter def metadata(self, metadata): if not self.user_data_software_config(): self._metadata = metadata def user_data_raw(self): return self.properties.get(self.USER_DATA_FORMAT) == self.RAW def user_data_software_config(self): return self.properties.get( self.USER_DATA_FORMAT) == self.SOFTWARE_CONFIG def transport_poll_server_cfn(self): return self.properties.get( self.SOFTWARE_CONFIG_TRANSPORT) == self.POLL_SERVER_CFN def transport_poll_server_heat(self): return self.properties.get( self.SOFTWARE_CONFIG_TRANSPORT) == self.POLL_SERVER_HEAT def handle_create(self): security_groups = self.properties.get(self.SECURITY_GROUPS) user_data_format = self.properties.get(self.USER_DATA_FORMAT) ud_content = self.properties.get(self.USER_DATA) if self.user_data_software_config() or self.user_data_raw(): if uuidutils.is_uuid_like(ud_content): # attempt to load the userdata from software config try: ud_content = sc.SoftwareConfig.get_software_config( self.heat(), ud_content) except exception.SoftwareConfigMissing: # no config was found, so do not modify the user_data pass if self.user_data_software_config(): self._create_transport_credentials() if self.properties[self.ADMIN_USER]: instance_user = self.properties[self.ADMIN_USER] elif cfg.CONF.instance_user: instance_user = cfg.CONF.instance_user else: instance_user = None userdata = nova_utils.build_userdata( self, ud_content, instance_user=instance_user, user_data_format=user_data_format) flavor = self.properties[self.FLAVOR] availability_zone = self.properties[self.AVAILABILITY_ZONE] image = self.properties.get(self.IMAGE) if image: image = nova_utils.get_image_id(self.nova(), image) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) instance_meta = self.properties.get(self.METADATA) if instance_meta is not None: instance_meta = nova_utils.meta_serialize(instance_meta) scheduler_hints = self.properties.get(self.SCHEDULER_HINTS) nics = self._build_nics(self.properties.get(self.NETWORKS)) block_device_mapping = self._build_block_device_mapping( self.properties.get(self.BLOCK_DEVICE_MAPPING)) reservation_id = self.properties.get(self.RESERVATION_ID) config_drive = self.properties.get(self.CONFIG_DRIVE) disk_config = self.properties.get(self.DISK_CONFIG) admin_pass = self.properties.get(self.ADMIN_PASS) or None server = None try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image, flavor=flavor_id, key_name=self._key_name(), security_groups=security_groups, userdata=userdata, meta=instance_meta, scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone, block_device_mapping=block_device_mapping, reservation_id=reservation_id, config_drive=config_drive, disk_config=disk_config, files=self._personality(), admin_pass=admin_pass) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server def check_create_complete(self, server): return self._check_active(server) def _check_active(self, server): if server.status != 'ACTIVE': nova_utils.refresh_server(server) # Some clouds append extra (STATUS) strings to the status short_server_status = server.status.split('(')[0] if short_server_status in nova_utils.deferred_server_statuses: return False elif server.status == 'ACTIVE': return True elif server.status == 'ERROR': exc = exception.Error(_('Creation of server %s failed.') % server.name) raise exc else: exc = exception.Error(_('Creation of server %(server)s failed ' 'with unknown status: %(status)s') % dict(server=server.name, status=server.status)) raise exc @classmethod def _build_block_device_mapping(cls, bdm): if not bdm: return None bdm_dict = {} for mapping in bdm: mapping_parts = [] snapshot_id = mapping.get(cls.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID) if snapshot_id: mapping_parts.append(snapshot_id) mapping_parts.append('snap') else: volume_id = mapping.get(cls.BLOCK_DEVICE_MAPPING_VOLUME_ID) mapping_parts.append(volume_id) mapping_parts.append('') volume_size = mapping.get(cls.BLOCK_DEVICE_MAPPING_VOLUME_SIZE) delete = mapping.get(cls.BLOCK_DEVICE_MAPPING_DELETE_ON_TERM) if volume_size or delete: mapping_parts.append(str(volume_size or 0)) if delete: mapping_parts.append(str(delete)) device_name = mapping.get(cls.BLOCK_DEVICE_MAPPING_DEVICE_NAME) bdm_dict[device_name] = ':'.join(mapping_parts) return bdm_dict def _build_nics(self, networks): if not networks: return None nics = [] for net_data in networks: nic_info = {} if net_data.get(self.NETWORK_UUID): nic_info['net-id'] = net_data[self.NETWORK_UUID] label_or_uuid = net_data.get(self.NETWORK_ID) if label_or_uuid: if uuidutils.is_uuid_like(label_or_uuid): nic_info['net-id'] = label_or_uuid else: network = self.nova().networks.find(label=label_or_uuid) nic_info['net-id'] = network.id if net_data.get(self.NETWORK_FIXED_IP): nic_info['v4-fixed-ip'] = net_data[self.NETWORK_FIXED_IP] if net_data.get(self.NETWORK_PORT): nic_info['port-id'] = net_data[self.NETWORK_PORT] nics.append(nic_info) return nics def _add_port_for_address(self, server): nets = copy.deepcopy(server.addresses) ifaces = server.interface_list() ip_mac_mapping_on_port_id = dict(((iface.fixed_ips[0]['ip_address'], iface.mac_addr), iface.port_id) for iface in ifaces) for net_name in nets: for addr in nets[net_name]: addr['port'] = ip_mac_mapping_on_port_id.get( (addr['addr'], addr['OS-EXT-IPS-MAC:mac_addr'])) return nets def _resolve_attribute(self, name): if name == 'first_address': return nova_utils.server_to_ipaddress( self.nova(), self.resource_id) or '' try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound as ex: logger.warn(_('Instance (%(server)s) not found: %(ex)s') % { 'server': self.resource_id, 'ex': str(ex)}) return '' if name == 'addresses': return self._add_port_for_address(server) if name == 'networks': return server.networks if name == 'instance_name': return server._info.get('OS-EXT-SRV-ATTR:instance_name') if name == 'accessIPv4': return server.accessIPv4 if name == 'accessIPv6': return server.accessIPv6 if name == 'show': return server._info def add_dependencies(self, deps): super(Server, self).add_dependencies(deps) # Depend on any Subnet in this template with the same # network_id as the networks attached to this server. # It is not known which subnet a server might be assigned # to so all subnets in a network should be created before # the servers in that network. for res in self.stack.itervalues(): if (res.has_interface('OS::Neutron::Subnet')): subnet_net = res.properties.get(subnet.Subnet.NETWORK_ID) for net in self.properties.get(self.NETWORKS): # we do not need to worry about NETWORK_ID values which are # names instead of UUIDs since these were not created # by this stack net_id = (net.get(self.NETWORK_ID) or net.get(self.NETWORK_UUID)) if net_id and net_id == subnet_net: deps += (self, res) break def _get_network_matches(self, old_networks, new_networks): # make new_networks similar on old_networks for net in new_networks: for key in ('port', 'network', 'fixed_ip'): net.setdefault(key) # find matches and remove them from old and new networks not_updated_networks = [] for net in old_networks: net.pop('uuid', None) if net in new_networks: new_networks.remove(net) not_updated_networks.append(net) for net in not_updated_networks: old_networks.remove(net) return not_updated_networks def update_networks_matching_iface_port(self, nets, interfaces): def find_equal(port, net_id, ip, nets): for net in nets: if (net.get('port') == port or (net.get('fixed_ip') == ip and net.get('network') == net_id)): return net def find_poor_net(net_id, nets): for net in nets: if net == {'port': None, 'network': net_id, 'fixed_ip': None}: return net for iface in interfaces: # get interface properties props = {'port': iface.port_id, 'net_id': iface.net_id, 'ip': iface.fixed_ips[0]['ip_address'], 'nets': nets} # try to match by port or network_id with fixed_ip net = find_equal(**props) if net is not None: net['port'] = props['port'] continue # find poor net that has only network_id net = find_poor_net(props['net_id'], nets) if net is not None: net['port'] = props['port'] def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] checkers = [] server = None if self.METADATA in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, prop_diff[self.METADATA]) if self.FLAVOR in prop_diff: flavor_update_policy = ( prop_diff.get(self.FLAVOR_UPDATE_POLICY) or self.properties.get(self.FLAVOR_UPDATE_POLICY)) if flavor_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) flavor = prop_diff[self.FLAVOR] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checkers.append(checker) if self.IMAGE in prop_diff: image_update_policy = ( prop_diff.get(self.IMAGE_UPDATE_POLICY) or self.properties.get(self.IMAGE_UPDATE_POLICY)) if image_update_policy == 'REPLACE': raise resource.UpdateReplace(self.name) image = prop_diff[self.IMAGE] image_id = nova_utils.get_image_id(self.nova(), image) if not server: server = self.nova().servers.get(self.resource_id) preserve_ephemeral = ( image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL') checker = scheduler.TaskRunner( nova_utils.rebuild, server, image_id, preserve_ephemeral=preserve_ephemeral) checkers.append(checker) if self.NAME in prop_diff: if not server: server = self.nova().servers.get(self.resource_id) nova_utils.rename(server, prop_diff[self.NAME]) if self.NETWORKS in prop_diff: new_networks = prop_diff.get(self.NETWORKS) attach_first_free_port = False if not new_networks: new_networks = [] attach_first_free_port = True old_networks = self.properties.get(self.NETWORKS) if not server: server = self.nova().servers.get(self.resource_id) interfaces = server.interface_list() # if old networks is None, it means that the server got first # free port. so we should detach this interface. if old_networks is None: for iface in interfaces: checker = scheduler.TaskRunner(server.interface_detach, iface.port_id) checkers.append(checker) # if we have any information in networks field, we should: # 1. find similar networks, if they exist # 2. remove these networks from new_networks and old_networks # lists # 3. detach unmatched networks, which were present in old_networks # 4. attach unmatched networks, which were present in new_networks else: # remove not updated networks from old and new networks lists, # also get list these networks not_updated_networks = \ self._get_network_matches(old_networks, new_networks) self.update_networks_matching_iface_port( old_networks + not_updated_networks, interfaces) # according to nova interface-detach command detached port # will be deleted for net in old_networks: checker = scheduler.TaskRunner(server.interface_detach, net.get('port')) checkers.append(checker) # attach section similar for both variants that # were mentioned above for net in new_networks: if net.get('port'): checker = scheduler.TaskRunner(server.interface_attach, net['port'], None, None) checkers.append(checker) elif net.get('network'): checker = scheduler.TaskRunner(server.interface_attach, None, net['network'], net.get('fixed_ip')) checkers.append(checker) # if new_networks is None, we should attach first free port, # according to similar behavior during instance creation if attach_first_free_port: checker = scheduler.TaskRunner(server.interface_attach, None, None, None) checkers.append(checker) # Optimization: make sure the first task is started before # check_update_complete. if checkers: checkers[0].start() return checkers def check_update_complete(self, checkers): '''Push all checkers to completion in list order.''' for checker in checkers: if not checker.started(): checker.start() if not checker.step(): return False return True def metadata_update(self, new_metadata=None): ''' Refresh the metadata if new_metadata is None ''' if new_metadata is None: self.metadata = self.parsed_template('Metadata') @staticmethod def _check_maximum(count, maximum, msg): ''' Check a count against a maximum, unless maximum is -1 which indicates that there is no limit ''' if maximum != -1 and count > maximum: raise exception.StackValidationFailed(message=msg) def validate(self): ''' Validate any of the provided params ''' super(Server, self).validate() # either volume_id or snapshot_id needs to be specified, but not both # for block device mapping. bdm = self.properties.get(self.BLOCK_DEVICE_MAPPING) or [] bootable_vol = False for mapping in bdm: device_name = mapping[self.BLOCK_DEVICE_MAPPING_DEVICE_NAME] if device_name == 'vda': bootable_vol = True volume_id = mapping.get(self.BLOCK_DEVICE_MAPPING_VOLUME_ID) snapshot_id = mapping.get(self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID) if volume_id and snapshot_id: raise exception.ResourcePropertyConflict( self.BLOCK_DEVICE_MAPPING_VOLUME_ID, self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID) if not volume_id and not snapshot_id: msg = _('Either volume_id or snapshot_id must be specified for' ' device mapping %s') % device_name raise exception.StackValidationFailed(message=msg) # make sure the image exists if specified. image = self.properties.get(self.IMAGE) if not image and not bootable_vol: msg = _('Neither image nor bootable volume is specified for' ' instance %s') % self.name raise exception.StackValidationFailed(message=msg) # network properties 'uuid' and 'network' shouldn't be used # both at once for all networks networks = self.properties.get(self.NETWORKS) or [] # record if any networks include explicit ports networks_with_port = False for network in networks: networks_with_port = networks_with_port or \ network.get(self.NETWORK_PORT) if network.get(self.NETWORK_UUID) and network.get(self.NETWORK_ID): msg = _('Properties "%(uuid)s" and "%(id)s" are both set ' 'to the network "%(network)s" for the server ' '"%(server)s". The "%(uuid)s" property is deprecated. ' 'Use only "%(id)s" property.' '') % dict(uuid=self.NETWORK_UUID, id=self.NETWORK_ID, network=network[self.NETWORK_ID], server=self.name) raise exception.StackValidationFailed(message=msg) elif network.get(self.NETWORK_UUID): logger.info(_('For the server "%(server)s" the "%(uuid)s" ' 'property is set to network "%(network)s". ' '"%(uuid)s" property is deprecated. Use ' '"%(id)s" property instead.' '') % dict(uuid=self.NETWORK_UUID, id=self.NETWORK_ID, network=network[self.NETWORK_ID], server=self.name)) # retrieve provider's absolute limits if it will be needed metadata = self.properties.get(self.METADATA) personality = self._personality() if metadata is not None or personality: limits = nova_utils.absolute_limits(self.nova()) # if 'security_groups' present for the server and explict 'port' # in one or more entries in 'networks', raise validation error if networks_with_port and self.properties.get(self.SECURITY_GROUPS): raise exception.ResourcePropertyConflict( self.SECURITY_GROUPS, "/".join([self.NETWORKS, self.NETWORK_PORT])) # verify that the number of metadata entries is not greater # than the maximum number allowed in the provider's absolute # limits if metadata is not None: msg = _('Instance metadata must not contain greater than %s ' 'entries. This is the maximum number allowed by your ' 'service provider') % limits['maxServerMeta'] self._check_maximum(len(metadata), limits['maxServerMeta'], msg) # verify the number of personality files and the size of each # personality file against the provider's absolute limits if personality: msg = _("The personality property may not contain " "greater than %s entries.") % limits['maxPersonality'] self._check_maximum(len(personality), limits['maxPersonality'], msg) for path, contents in personality.items(): msg = (_("The contents of personality file \"%(path)s\" " "is larger than the maximum allowed personality " "file size (%(max_size)s bytes).") % {'path': path, 'max_size': limits['maxPersonalitySize']}) self._check_maximum(len(bytes(contents)), limits['maxPersonalitySize'], msg) def handle_delete(self): ''' Delete a server, blocking until it is disposed by OpenStack ''' if self.resource_id is None: return if self.user_data_software_config(): self._delete_user() try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound: pass else: delete = scheduler.TaskRunner(nova_utils.delete_server, server) delete(wait_time=0.2) self.resource_id_set(None) def handle_suspend(self): ''' Suspend a server - note we do not wait for the SUSPENDED state, this is polled for by check_suspend_complete in a similar way to the create logic so we can take advantage of coroutines ''' if self.resource_id is None: raise exception.Error(_('Cannot suspend %s, resource_id not set') % self.name) try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound: raise exception.NotFound(_('Failed to find server %s') % self.resource_id) else: logger.debug(_('suspending server %s') % self.resource_id) # We want the server.suspend to happen after the volume # detachement has finished, so pass both tasks and the server suspend_runner = scheduler.TaskRunner(server.suspend) return server, suspend_runner def check_suspend_complete(self, cookie): server, suspend_runner = cookie if not suspend_runner.started(): suspend_runner.start() if suspend_runner.done(): if server.status == 'SUSPENDED': return True nova_utils.refresh_server(server) logger.debug(_('%(name)s check_suspend_complete status ' '= %(status)s') % { 'name': self.name, 'status': server.status}) if server.status in list(nova_utils.deferred_server_statuses + ['ACTIVE']): return server.status == 'SUSPENDED' else: exc = exception.Error(_('Suspend of server %(server)s failed ' 'with unknown status: %(status)s') % dict(server=server.name, status=server.status)) raise exc def handle_resume(self): ''' Resume a server - note we do not wait for the ACTIVE state, this is polled for by check_resume_complete in a similar way to the create logic so we can take advantage of coroutines ''' if self.resource_id is None: raise exception.Error(_('Cannot resume %s, resource_id not set') % self.name) try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound: raise exception.NotFound(_('Failed to find server %s') % self.resource_id) else: logger.debug(_('resuming server %s') % self.resource_id) server.resume() return server def check_resume_complete(self, server): return self._check_active(server) class FlavorConstraint(object): def validate(self, value, context): nova_client = clients.Clients(context).nova() try: nova_utils.get_flavor_id(nova_client, value) except exception.FlavorMissing: return False else: return True def constraint_mapping(): return {'nova.flavor': FlavorConstraint} def resource_mapping(): return { 'OS::Nova::Server': Server, } heat-2014.1.5/heat/engine/resources/resource_group.py0000664000567000056700000001422412540642614023651 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. import copy from heat.common import exception from heat.engine import constraints from heat.engine import parser from heat.engine import properties from heat.engine import stack_resource from heat.openstack.common.gettextutils import _ template_template = { "heat_template_version": "2013-05-23", "resources": {} } class ResourceGroup(stack_resource.StackResource): """ A resource that creates one or more identically configured nested resources. In addition to the "refs" attribute, this resource implements synthetic attributes that mirror those of the resources in the group. When getting an attribute from this resource, however, a list of attribute values for each resource in the group is returned. To get attribute values for a single resource in the group, synthetic attributes of the form "resource.{resource index}.{attribute name}" can be used. The resource ID of a particular resource in the group can be obtained via the synthetic attribute "resource.{resource index}". """ PROPERTIES = ( COUNT, RESOURCE_DEF, ) = ( 'count', 'resource_def', ) _RESOURCE_DEF_KEYS = ( RESOURCE_DEF_TYPE, RESOURCE_DEF_PROPERTIES, ) = ( 'type', 'properties', ) properties_schema = { COUNT: properties.Schema( properties.Schema.INTEGER, _('The number of instances to create.'), default=1, constraints=[ constraints.Range(min=1), ], update_allowed=True ), RESOURCE_DEF: properties.Schema( properties.Schema.MAP, _('Resource definition for the resources in the group. The value ' 'of this property is the definition of a resource just as if ' 'it had been declared in the template itself.'), schema={ RESOURCE_DEF_TYPE: properties.Schema( properties.Schema.STRING, _('The type of the resources in the group'), required=True ), RESOURCE_DEF_PROPERTIES: properties.Schema( properties.Schema.MAP, _('Property values for the resources in the group') ), }, required=True ), } attributes_schema = { "refs": _("A list of resource IDs for the resources in the group") } update_allowed_keys = ("Properties",) def validate(self): # validate our basic properties super(ResourceGroup, self).validate() # make sure the nested resource is valid test_tmpl = self._assemble_nested(1, include_all=True) val_templ = parser.Template(test_tmpl) res_def = val_templ["Resources"]["0"] res_class = self.stack.env.get_class(res_def['Type']) res_inst = res_class("%s:resource_def" % self.name, res_def, self.stack) res_inst.validate() def handle_create(self): count = self.properties[self.COUNT] return self.create_with_template(self._assemble_nested(count), {}, self.stack.timeout_mins) def handle_update(self, new_snippet, tmpl_diff, prop_diff): count = prop_diff.get(self.COUNT) if count: return self.update_with_template(self._assemble_nested(count), {}, self.stack.timeout_mins) def handle_delete(self): return self.delete_nested() def FnGetAtt(self, key): if key.startswith("resource."): parts = key.split(".", 2) attr_name = parts[-1] if len(parts) > 2 else None try: res = self.nested()[parts[1]] except KeyError: raise exception.InvalidTemplateAttribute(resource=self.name, key=key) else: return (res.FnGetRefId() if attr_name is None else res.FnGetAtt(attr_name)) else: def get_aggregated_attr(func, *args): for n in range(self.properties[self.COUNT]): resource_method = getattr(self.nested()[str(n)], func) yield resource_method(*args) method_name, method_call = (("FnGetRefId", []) if "refs" == key else ("FnGetAtt", [key])) return [val for val in get_aggregated_attr(method_name, *method_call)] def _assemble_nested(self, count, include_all=False): child_template = copy.deepcopy(template_template) resource_def = self.properties[self.RESOURCE_DEF] if resource_def[self.RESOURCE_DEF_PROPERTIES] is None: resource_def[self.RESOURCE_DEF_PROPERTIES] = {} if not include_all: resource_def_props = resource_def[self.RESOURCE_DEF_PROPERTIES] clean = dict((k, v) for k, v in resource_def_props.items() if v) resource_def[self.RESOURCE_DEF_PROPERTIES] = clean resources = dict((str(k), resource_def) for k in range(count)) child_template['resources'] = resources return child_template def child_template(self): count = self.properties[self.COUNT] return self._assemble_nested(count) def child_params(self): return {} def resource_mapping(): return { 'OS::Heat::ResourceGroup': ResourceGroup, } heat-2014.1.5/heat/engine/resources/vpc.py0000664000567000056700000001076212540642614021401 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. from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources.neutron import neutron from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class VPC(resource.Resource): PROPERTIES = ( CIDR_BLOCK, INSTANCE_TENANCY, TAGS, ) = ( 'CidrBlock', 'InstanceTenancy', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { CIDR_BLOCK: properties.Schema( properties.Schema.STRING, _('CIDR block to apply to the VPC.') ), INSTANCE_TENANCY: properties.Schema( properties.Schema.STRING, _('Allowed tenancy of instances launched in the VPC. default - ' 'any tenancy; dedicated - instance will be dedicated, ' 'regardless of the tenancy option specified at instance ' 'launch.'), default='default', constraints=[ constraints.AllowedValues(['default', 'dedicated']), ], implemented=False ), TAGS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, _('List of tags to attach to the instance.'), schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, implemented=False, ) ), } def handle_create(self): client = self.neutron() # The VPC's net and router are associated by having identical names. net_props = {'name': self.physical_resource_name()} router_props = {'name': self.physical_resource_name()} net = client.create_network({'network': net_props})['network'] client.create_router({'router': router_props})['router'] self.resource_id_set(net['id']) @staticmethod def network_for_vpc(client, network_id): return client.show_network(network_id)['network'] @staticmethod def router_for_vpc(client, network_id): # first get the neutron net net = VPC.network_for_vpc(client, network_id) # then find a router with the same name routers = client.list_routers(name=net['name'])['routers'] if len(routers) == 0: # There may be no router if the net was created manually # instead of in another stack. return None if len(routers) > 1: raise exception.Error( _('Multiple routers found with name %s') % net['name']) return routers[0] def check_create_complete(self, *args): net = self.network_for_vpc(self.neutron(), self.resource_id) if not neutron.NeutronResource.is_built(net): return False router = self.router_for_vpc(self.neutron(), self.resource_id) return neutron.NeutronResource.is_built(router) def handle_delete(self): from neutronclient.common.exceptions import NeutronClientException client = self.neutron() router = self.router_for_vpc(client, self.resource_id) try: client.delete_router(router['id']) except NeutronClientException as ex: if ex.status_code != 404: raise ex try: client.delete_network(self.resource_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex def resource_mapping(): if clients.neutronclient is None: return {} return { 'AWS::EC2::VPC': VPC, } heat-2014.1.5/heat/engine/resources/security_group.py0000664000567000056700000002533412540642614023675 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. from heat.common import exception from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class SecurityGroup(resource.Resource): PROPERTIES = ( GROUP_DESCRIPTION, VPC_ID, SECURITY_GROUP_INGRESS, SECURITY_GROUP_EGRESS, ) = ( 'GroupDescription', 'VpcId', 'SecurityGroupIngress', 'SecurityGroupEgress', ) _RULE_KEYS = ( RULE_CIDR_IP, RULE_FROM_PORT, RULE_TO_PORT, RULE_IP_PROTOCOL, RULE_SOURCE_SECURITY_GROUP_ID, RULE_SOURCE_SECURITY_GROUP_NAME, RULE_SOURCE_SECURITY_GROUP_OWNER_ID, ) = ( 'CidrIp', 'FromPort', 'ToPort', 'IpProtocol', 'SourceSecurityGroupId', 'SourceSecurityGroupName', 'SourceSecurityGroupOwnerId', ) _rule_schema = { RULE_CIDR_IP: properties.Schema( properties.Schema.STRING ), RULE_FROM_PORT: properties.Schema( properties.Schema.STRING ), RULE_TO_PORT: properties.Schema( properties.Schema.STRING ), RULE_IP_PROTOCOL: properties.Schema( properties.Schema.STRING ), RULE_SOURCE_SECURITY_GROUP_ID: properties.Schema( properties.Schema.STRING ), RULE_SOURCE_SECURITY_GROUP_NAME: properties.Schema( properties.Schema.STRING ), RULE_SOURCE_SECURITY_GROUP_OWNER_ID: properties.Schema( properties.Schema.STRING, implemented=False ), } properties_schema = { GROUP_DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description of the security group.'), required=True ), VPC_ID: properties.Schema( properties.Schema.STRING, _('Physical ID of the VPC.') ), SECURITY_GROUP_INGRESS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, _('List of security group ingress rules.'), schema=_rule_schema, ) ), SECURITY_GROUP_EGRESS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, _('List of security group egress rules.'), schema=_rule_schema, ) ), } def handle_create(self): if self.properties[self.VPC_ID] and clients.neutronclient is not None: self._handle_create_neutron() else: self._handle_create_nova() def _convert_to_neutron_rule(self, direction, sg_rule): return { 'direction': direction, 'ethertype': 'IPv4', 'remote_ip_prefix': sg_rule.get(self.RULE_CIDR_IP), 'port_range_min': sg_rule.get(self.RULE_FROM_PORT), 'port_range_max': sg_rule.get(self.RULE_TO_PORT), 'protocol': sg_rule.get(self.RULE_IP_PROTOCOL), # Neutron understands both names and ids 'remote_group_id': sg_rule.get(self.RULE_SOURCE_SECURITY_GROUP_ID) or sg_rule.get(self.RULE_SOURCE_SECURITY_GROUP_NAME), 'security_group_id': self.resource_id } def _handle_create_neutron(self): from neutronclient.common.exceptions import NeutronClientException client = self.neutron() sec = client.create_security_group({'security_group': { 'name': self.physical_resource_name(), 'description': self.properties[self.GROUP_DESCRIPTION]} })['security_group'] def sanitize_security_group(i): # Neutron only accepts positive ints if (i.get(self.RULE_FROM_PORT) is not None and int(i[self.RULE_FROM_PORT]) < 0): i[self.RULE_FROM_PORT] = None if (i.get(self.RULE_TO_PORT) is not None and int(i[self.RULE_TO_PORT]) < 0): i[self.RULE_TO_PORT] = None if (i.get(self.RULE_FROM_PORT) is None and i.get(self.RULE_TO_PORT) is None): i[self.RULE_CIDR_IP] = None self.resource_id_set(sec['id']) if self.properties[self.SECURITY_GROUP_INGRESS]: for i in self.properties[self.SECURITY_GROUP_INGRESS]: sanitize_security_group(i) try: rule = client.create_security_group_rule({ 'security_group_rule': self._convert_to_neutron_rule('ingress', i) }) except NeutronClientException as ex: if ex.status_code == 409: # no worries, the rule is already there pass else: # unexpected error raise if self.properties[self.SECURITY_GROUP_EGRESS]: # Delete the default rules which allow all egress traffic for rule in sec['security_group_rules']: if rule['direction'] == 'egress': client.delete_security_group_rule(rule['id']) for i in self.properties[self.SECURITY_GROUP_EGRESS]: sanitize_security_group(i) try: rule = client.create_security_group_rule({ 'security_group_rule': self._convert_to_neutron_rule('egress', i) }) except NeutronClientException as ex: if ex.status_code == 409: # no worries, the rule is already there pass else: # unexpected error raise def _handle_create_nova(self): sec = None groups = self.nova().security_groups.list() for group in groups: if group.name == self.physical_resource_name(): sec = group break if not sec: sec = self.nova().security_groups.create( self.physical_resource_name(), self.properties[self.GROUP_DESCRIPTION]) self.resource_id_set(sec.id) if self.properties[self.SECURITY_GROUP_INGRESS]: rules_client = self.nova().security_group_rules for i in self.properties[self.SECURITY_GROUP_INGRESS]: source_group_id = None if i.get(self.RULE_SOURCE_SECURITY_GROUP_ID) is not None: source_group_id = i[self.RULE_SOURCE_SECURITY_GROUP_ID] elif i.get(self.RULE_SOURCE_SECURITY_GROUP_NAME) is not None: rule_name = i[self.RULE_SOURCE_SECURITY_GROUP_NAME] for group in groups: if group.name == rule_name: source_group_id = group.id break else: raise SecurityGroupNotFound(group_name=rule_name) try: rules_client.create( sec.id, i.get(self.RULE_IP_PROTOCOL), i.get(self.RULE_FROM_PORT), i.get(self.RULE_TO_PORT), i.get(self.RULE_CIDR_IP), source_group_id) except clients.novaclient.exceptions.BadRequest as ex: if ex.message.find('already exists') >= 0: # no worries, the rule is already there pass else: # unexpected error raise def handle_delete(self): if self.properties[self.VPC_ID] and clients.neutronclient is not None: self._handle_delete_neutron() else: self._handle_delete_nova() def _handle_delete_nova(self): if self.resource_id is not None: try: sec = self.nova().security_groups.get(self.resource_id) except clients.novaclient.exceptions.NotFound: pass else: for rule in sec.rules: try: self.nova().security_group_rules.delete(rule['id']) except clients.novaclient.exceptions.NotFound: pass self.nova().security_groups.delete(self.resource_id) self.resource_id_set(None) def _handle_delete_neutron(self): from neutronclient.common.exceptions import NeutronClientException client = self.neutron() if self.resource_id is not None: try: sec = client.show_security_group( self.resource_id)['security_group'] except NeutronClientException as ex: if ex.status_code != 404: raise else: for rule in sec['security_group_rules']: try: client.delete_security_group_rule(rule['id']) except NeutronClientException as ex: if ex.status_code != 404: raise try: client.delete_security_group(self.resource_id) except NeutronClientException as ex: if ex.status_code != 404: raise self.resource_id_set(None) def FnGetRefId(self): if self.properties[self.VPC_ID]: return super(SecurityGroup, self).FnGetRefId() else: return self.physical_resource_name() def validate(self): res = super(SecurityGroup, self).validate() if res: return res if self.properties[self.SECURITY_GROUP_EGRESS] and not( self.properties[self.VPC_ID] and clients.neutronclient is not None): raise exception.EgressRuleNotAllowed() class SecurityGroupNotFound(exception.HeatException): msg_fmt = _('Security Group "%(group_name)s" not found') def resource_mapping(): return { 'AWS::EC2::SecurityGroup': SecurityGroup, } heat-2014.1.5/heat/engine/resources/image.py0000664000567000056700000000204712540642614021670 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. from heat.common import exception from heat.engine import clients from heat.engine.resources import nova_utils class ImageConstraint(object): def validate(self, value, context): try: nova_client = clients.Clients(context).nova() nova_utils.get_image_id(nova_client, value) except exception.ImageNotFound: return False else: return True def constraint_mapping(): return {'glance.image': ImageConstraint} heat-2014.1.5/heat/engine/resources/__init__.py0000664000567000056700000000411612540642614022344 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. from heat.engine import environment from heat.engine import plugin_manager def _register_resources(env, type_pairs): for res_name, res_class in type_pairs: env.register_class(res_name, res_class) def _register_constraints(env, type_pairs): for constraint_name, constraint in type_pairs: env.register_constraint(constraint_name, constraint) _environment = None def global_env(): if _environment is None: initialise() return _environment def initialise(): global _environment if _environment is not None: return global_env = environment.Environment({}, user_env=False) _load_global_environment(global_env) _environment = global_env def _load_global_environment(env): _load_global_resources(env) environment.read_global_environment(env) def _load_global_resources(env): manager = plugin_manager.PluginManager(__name__) # Sometimes resources should not be available for registration in Heat due # to unsatisfied dependencies. We look first for the function # 'available_resource_mapping', which should return the filtered resources. # If it is not found, we look for the legacy 'resource_mapping'. resource_mapping = plugin_manager.PluginMapping(['available_resource', 'resource']) constraint_mapping = plugin_manager.PluginMapping('constraint') _register_resources(env, resource_mapping.load_all(manager)) _register_constraints(env, constraint_mapping.load_all(manager)) heat-2014.1.5/heat/engine/resources/instance.py0000664000567000056700000006435112540642614022420 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. from oslo.config import cfg cfg.CONF.import_opt('instance_user', 'heat.common.config') from heat.common import exception from heat.engine import clients from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources.network_interface import NetworkInterface from heat.engine.resources.neutron import neutron from heat.engine.resources import nova_utils from heat.engine.resources import volume from heat.engine import scheduler from heat.engine import signal_responder from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class Restarter(signal_responder.SignalResponder): PROPERTIES = ( INSTANCE_ID, ) = ( 'InstanceId', ) properties_schema = { INSTANCE_ID: properties.Schema( properties.Schema.STRING, _('Instance ID to be restarted.'), required=True ), } attributes_schema = { "AlarmUrl": _("A signed url to handle the alarm " "(Heat extension).") } def _find_resource(self, resource_id): ''' Return the resource with the specified instance ID, or None if it cannot be found. ''' for resource in self.stack.itervalues(): if resource.resource_id == resource_id: return resource return None def handle_create(self): super(Restarter, self).handle_create() self.resource_id_set(self._get_user_id()) def handle_signal(self, details=None): if self.action in (self.SUSPEND, self.DELETE): msg = _('Cannot signal resource during %s') % self.action raise Exception(msg) if details is None: alarm_state = 'alarm' else: alarm_state = details.get('state', 'alarm').lower() logger.info(_('%(name)s Alarm, new state %(state)s') % { 'name': self.name, 'state': alarm_state}) if alarm_state != 'alarm': return victim = self._find_resource(self.properties[self.INSTANCE_ID]) if victim is None: logger.info(_('%(name)s Alarm, can not find instance ' '%(instance)s') % { 'name': self.name, 'instance': self.properties[self.INSTANCE_ID]}) return logger.info(_('%(name)s Alarm, restarting resource: %(victim)s') % { 'name': self.name, 'victim': victim.name}) self.stack.restart_resource(victim.name) def _resolve_attribute(self, name): ''' heat extension: "AlarmUrl" returns the url to post to the policy when there is an alarm. ''' if name == 'AlarmUrl' and self.resource_id is not None: return unicode(self._get_signed_url()) class Instance(resource.Resource): PROPERTIES = ( IMAGE_ID, INSTANCE_TYPE, KEY_NAME, AVAILABILITY_ZONE, DISABLE_API_TERMINATION, KERNEL_ID, MONITORING, PLACEMENT_GROUP_NAME, PRIVATE_IP_ADDRESS, RAM_DISK_ID, SECURITY_GROUPS, SECURITY_GROUP_IDS, NETWORK_INTERFACES, SOURCE_DEST_CHECK, SUBNET_ID, TAGS, NOVA_SCHEDULER_HINTS, TENANCY, USER_DATA, VOLUMES, ) = ( 'ImageId', 'InstanceType', 'KeyName', 'AvailabilityZone', 'DisableApiTermination', 'KernelId', 'Monitoring', 'PlacementGroupName', 'PrivateIpAddress', 'RamDiskId', 'SecurityGroups', 'SecurityGroupIds', 'NetworkInterfaces', 'SourceDestCheck', 'SubnetId', 'Tags', 'NovaSchedulerHints', 'Tenancy', 'UserData', 'Volumes', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) _NOVA_SCHEDULER_HINT_KEYS = ( NOVA_SCHEDULER_HINT_KEY, NOVA_SCHEDULER_HINT_VALUE, ) = ( 'Key', 'Value', ) _VOLUME_KEYS = ( VOLUME_DEVICE, VOLUME_ID, ) = ( 'Device', 'VolumeId', ) properties_schema = { IMAGE_ID: properties.Schema( properties.Schema.STRING, _('Glance image ID or name.'), constraints=[ constraints.CustomConstraint('glance.image') ], required=True ), # AWS does not require InstanceType but Heat does because the nova # create api call requires a flavor INSTANCE_TYPE: properties.Schema( properties.Schema.STRING, _('Nova instance type (flavor).'), required=True, update_allowed=True ), KEY_NAME: properties.Schema( properties.Schema.STRING, _('Optional Nova keypair name.'), constraints=[ constraints.CustomConstraint("nova.keypair") ] ), AVAILABILITY_ZONE: properties.Schema( properties.Schema.STRING, _('Availability zone to launch the instance in.') ), DISABLE_API_TERMINATION: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), KERNEL_ID: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), MONITORING: properties.Schema( properties.Schema.BOOLEAN, _('Not Implemented.'), implemented=False ), PLACEMENT_GROUP_NAME: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), PRIVATE_IP_ADDRESS: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), RAM_DISK_ID: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), SECURITY_GROUPS: properties.Schema( properties.Schema.LIST, _('Security group names to assign.') ), SECURITY_GROUP_IDS: properties.Schema( properties.Schema.LIST, _('Security group IDs to assign.') ), NETWORK_INTERFACES: properties.Schema( properties.Schema.LIST, _('Network interfaces to associate with instance.') ), SOURCE_DEST_CHECK: properties.Schema( properties.Schema.BOOLEAN, _('Not Implemented.'), implemented=False ), SUBNET_ID: properties.Schema( properties.Schema.STRING, _('Subnet ID to launch instance in.') ), TAGS: properties.Schema( properties.Schema.LIST, _('Tags to attach to instance.'), schema=properties.Schema( properties.Schema.MAP, schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, ), update_allowed=True ), NOVA_SCHEDULER_HINTS: properties.Schema( properties.Schema.LIST, _('Scheduler hints to pass to Nova (Heat extension).'), schema=properties.Schema( properties.Schema.MAP, schema={ NOVA_SCHEDULER_HINT_KEY: properties.Schema( properties.Schema.STRING, required=True ), NOVA_SCHEDULER_HINT_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, ) ), TENANCY: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), constraints=[ constraints.AllowedValues(['dedicated', 'default']), ], implemented=False ), USER_DATA: properties.Schema( properties.Schema.STRING, _('User data to pass to instance.') ), VOLUMES: properties.Schema( properties.Schema.LIST, _('Volumes to attach to instance.'), default=[], schema=properties.Schema( properties.Schema.MAP, schema={ VOLUME_DEVICE: properties.Schema( properties.Schema.STRING, _('The device where the volume is exposed on the ' 'instance. This assignment may not be honored and ' 'it is advised that the path ' '/dev/disk/by-id/virtio- be used ' 'instead.'), required=True ), VOLUME_ID: properties.Schema( properties.Schema.STRING, _('The ID of the volume to be attached.'), required=True ), } ) ), } attributes_schema = {'AvailabilityZone': _('The Availability Zone where ' 'the specified instance is ' 'launched.'), 'PrivateDnsName': _('Private DNS name of the' ' specified instance.'), 'PublicDnsName': _('Public DNS name of the specified ' 'instance.'), 'PrivateIp': _('Private IP address of the specified ' 'instance.'), 'PublicIp': _('Public IP address of the specified ' 'instance.')} update_allowed_keys = ('Metadata', 'Properties') # Server host name limit to 53 characters by due to typical default # linux HOST_NAME_MAX of 64, minus the .novalocal appended to the name physical_resource_name_limit = 53 def __init__(self, name, json_snippet, stack): super(Instance, self).__init__(name, json_snippet, stack) self.ipaddress = None def _set_ipaddress(self, networks): ''' Read the server's IP address from a list of networks provided by Nova ''' # Just record the first ipaddress for n in networks: if len(networks[n]) > 0: self.ipaddress = networks[n][0] break def _ipaddress(self): ''' Return the server's IP address, fetching it from Nova if necessary ''' if self.ipaddress is None: self.ipaddress = nova_utils.server_to_ipaddress( self.nova(), self.resource_id) return self.ipaddress or '0.0.0.0' def _resolve_attribute(self, name): res = None if name == 'AvailabilityZone': res = self.properties[self.AVAILABILITY_ZONE] elif name in ['PublicIp', 'PrivateIp', 'PublicDnsName', 'PrivateDnsName']: res = self._ipaddress() logger.info(_('%(name)s._resolve_attribute(%(attname)s) == %(res)s'), {'name': self.name, 'attname': name, 'res': res}) return unicode(res) if res else None def _build_nics(self, network_interfaces, security_groups=None, subnet_id=None): nics = None if network_interfaces: unsorted_nics = [] for entry in network_interfaces: nic = (entry if not isinstance(entry, basestring) else {'NetworkInterfaceId': entry, 'DeviceIndex': len(unsorted_nics)}) unsorted_nics.append(nic) sorted_nics = sorted(unsorted_nics, key=lambda nic: int(nic['DeviceIndex'])) nics = [{'port-id': nic['NetworkInterfaceId']} for nic in sorted_nics] else: # if SubnetId property in Instance, ensure subnet exists if subnet_id: neutronclient = self.neutron() network_id = NetworkInterface.network_id_from_subnet_id( neutronclient, subnet_id) # if subnet verified, create a port to use this subnet # if port is not created explicitly, nova will choose # the first subnet in the given network. if network_id: fixed_ip = {'subnet_id': subnet_id} props = { 'admin_state_up': True, 'network_id': network_id, 'fixed_ips': [fixed_ip] } if security_groups: props['security_groups'] = \ neutron.NeutronResource.get_secgroup_uuids( security_groups, self.neutron()) port = neutronclient.create_port({'port': props})['port'] nics = [{'port-id': port['id']}] return nics def _get_security_groups(self): security_groups = [] for key in (self.SECURITY_GROUPS, self.SECURITY_GROUP_IDS): if self.properties.get(key) is not None: for sg in self.properties.get(key): security_groups.append(sg) if not security_groups: security_groups = None return security_groups def _get_nova_metadata(self, properties): if properties is None or properties.get(self.TAGS) is None: return None return dict((tm[self.TAG_KEY], tm[self.TAG_VALUE]) for tm in properties[self.TAGS]) def handle_create(self): security_groups = self._get_security_groups() userdata = self.properties[self.USER_DATA] or '' flavor = self.properties[self.INSTANCE_TYPE] availability_zone = self.properties[self.AVAILABILITY_ZONE] image_name = self.properties[self.IMAGE_ID] image_id = nova_utils.get_image_id(self.nova(), image_name) flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) scheduler_hints = {} if self.properties[self.NOVA_SCHEDULER_HINTS]: for tm in self.properties[self.NOVA_SCHEDULER_HINTS]: scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE] else: scheduler_hints = None nics = self._build_nics(self.properties[self.NETWORK_INTERFACES], security_groups=security_groups, subnet_id=self.properties[self.SUBNET_ID]) server = None # FIXME(shadower): the instance_user config option is deprecated. Once # it's gone, we should always use ec2-user for compatibility with # CloudFormation. if cfg.CONF.instance_user: instance_user = cfg.CONF.instance_user else: instance_user = 'ec2-user' try: server = self.nova().servers.create( name=self.physical_resource_name(), image=image_id, flavor=flavor_id, key_name=self.properties[self.KEY_NAME], security_groups=security_groups, userdata=nova_utils.build_userdata(self, userdata, instance_user), meta=self._get_nova_metadata(self.properties), scheduler_hints=scheduler_hints, nics=nics, availability_zone=availability_zone) finally: # Avoid a race condition where the thread could be cancelled # before the ID is stored if server is not None: self.resource_id_set(server.id) return server, scheduler.TaskRunner(self._attach_volumes_task()) def _attach_volumes_task(self): attach_tasks = (volume.VolumeAttachTask(self.stack, self.resource_id, volume_id, device) for volume_id, device in self.volumes()) return scheduler.PollingTaskGroup(attach_tasks) def check_create_complete(self, cookie): server, volume_attach_task = cookie return (self._check_active(server) and self._check_volume_attached(server, volume_attach_task)) def _check_volume_attached(self, server, volume_attach_task): if not volume_attach_task.started(): self._set_ipaddress(server.networks) volume_attach_task.start() return volume_attach_task.done() else: return volume_attach_task.step() def _check_active(self, server): if server.status != 'ACTIVE': nova_utils.refresh_server(server) if server.status == 'ACTIVE': return True # Some clouds append extra (STATUS) strings to the status short_server_status = server.status.split('(')[0] if short_server_status in nova_utils.deferred_server_statuses: return False if server.status == 'ERROR': fault = getattr(server, 'fault', {}) message = fault.get('message', 'Unknown') code = fault.get('code', 500) exc = exception.Error(_("Creation of server %(server)s " "failed: %(message)s (%(code)s)") % dict(server=server.name, message=message, code=code)) raise exc exc = exception.Error(_("Creation of server %(server)s failed " "with unknown status: %(status)s") % dict(server=server.name, status=server.status)) raise exc def volumes(self): """ Return an iterator over (volume_id, device) tuples for all volumes that should be attached to this instance. """ volumes = self.properties[self.VOLUMES] return ((vol[self.VOLUME_ID], vol[self.VOLUME_DEVICE]) for vol in volumes) def handle_update(self, json_snippet, tmpl_diff, prop_diff): if 'Metadata' in tmpl_diff: self.metadata = tmpl_diff['Metadata'] server = None if self.TAGS in prop_diff: server = self.nova().servers.get(self.resource_id) nova_utils.meta_update(self.nova(), server, self._get_nova_metadata(prop_diff)) if self.INSTANCE_TYPE in prop_diff: flavor = prop_diff[self.INSTANCE_TYPE] flavor_id = nova_utils.get_flavor_id(self.nova(), flavor) if not server: server = self.nova().servers.get(self.resource_id) checker = scheduler.TaskRunner(nova_utils.resize, server, flavor, flavor_id) checker.start() return checker def check_update_complete(self, checker): return checker.step() if checker is not None else True def metadata_update(self, new_metadata=None): ''' Refresh the metadata if new_metadata is None ''' if new_metadata is None: self.metadata = self.parsed_template('Metadata') def validate(self): ''' Validate any of the provided params ''' res = super(Instance, self).validate() if res: return res # check validity of security groups vs. network interfaces security_groups = self._get_security_groups() if security_groups and self.properties.get(self.NETWORK_INTERFACES): raise exception.ResourcePropertyConflict( '/'.join([self.SECURITY_GROUPS, self.SECURITY_GROUP_IDS]), self.NETWORK_INTERFACES) @scheduler.wrappertask def _delete_server(self, server): ''' Return a co-routine that deletes the server and waits for it to disappear from Nova. ''' yield self._detach_volumes_task()() server.delete() while True: yield try: nova_utils.refresh_server(server) if server.status == "DELETED": self.resource_id_set(None) break elif server.status == "ERROR": raise exception.Error(_("Deletion of server %s failed.") % server.id) except clients.novaclient.exceptions.NotFound: self.resource_id_set(None) break def _detach_volumes_task(self): ''' Detach volumes from the instance ''' detach_tasks = (volume.VolumeDetachTask(self.stack, self.resource_id, volume_id) for volume_id, device in self.volumes()) return scheduler.PollingTaskGroup(detach_tasks) def handle_delete(self): ''' Delete an instance, blocking until it is disposed by OpenStack ''' if self.resource_id is None: return try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound: self.resource_id_set(None) return server_delete_task = scheduler.TaskRunner(self._delete_server, server=server) server_delete_task.start() return server_delete_task def check_delete_complete(self, server_delete_task): # if the resource was already deleted, server_delete_task will be None if server_delete_task is None: return True else: return server_delete_task.step() def handle_suspend(self): ''' Suspend an instance - note we do not wait for the SUSPENDED state, this is polled for by check_suspend_complete in a similar way to the create logic so we can take advantage of coroutines ''' if self.resource_id is None: raise exception.Error(_('Cannot suspend %s, resource_id not set') % self.name) try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound: raise exception.NotFound(_('Failed to find instance %s') % self.resource_id) else: logger.debug(_("suspending instance %s") % self.resource_id) # We want the server.suspend to happen after the volume # detachement has finished, so pass both tasks and the server suspend_runner = scheduler.TaskRunner(server.suspend) volumes_runner = scheduler.TaskRunner(self._detach_volumes_task()) return server, suspend_runner, volumes_runner def check_suspend_complete(self, cookie): server, suspend_runner, volumes_runner = cookie if not volumes_runner.started(): volumes_runner.start() if volumes_runner.done(): if not suspend_runner.started(): suspend_runner.start() if suspend_runner.done(): if server.status == 'SUSPENDED': return True nova_utils.refresh_server(server) logger.debug(_("%(name)s check_suspend_complete " "status = %(status)s"), {'name': self.name, 'status': server.status}) if server.status in list(nova_utils.deferred_server_statuses + ['ACTIVE']): return server.status == 'SUSPENDED' else: raise exception.Error(_(' nova reported unexpected ' 'instance[%(instance)s] ' 'status[%(status)s]') % {'instance': self.name, 'status': server.status}) else: suspend_runner.step() else: volumes_runner.step() def handle_resume(self): ''' Resume an instance - note we do not wait for the ACTIVE state, this is polled for by check_resume_complete in a similar way to the create logic so we can take advantage of coroutines ''' if self.resource_id is None: raise exception.Error(_('Cannot resume %s, resource_id not set') % self.name) try: server = self.nova().servers.get(self.resource_id) except clients.novaclient.exceptions.NotFound: raise exception.NotFound(_('Failed to find instance %s') % self.resource_id) else: logger.debug(_("resuming instance %s") % self.resource_id) server.resume() return server, scheduler.TaskRunner(self._attach_volumes_task()) def check_resume_complete(self, cookie): server, volume_attach_task = cookie return (self._check_active(server) and self._check_volume_attached(server, volume_attach_task)) def resource_mapping(): return { 'AWS::EC2::Instance': Instance, 'OS::Heat::HARestarter': Restarter, } heat-2014.1.5/heat/engine/resources/cloud_watch.py0000664000567000056700000001660512540642614023107 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. from heat.common import exception from heat.engine import constraints from heat.engine import properties from heat.engine.properties import Properties from heat.engine import resource from heat.engine import watchrule from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class CloudWatchAlarm(resource.Resource): PROPERTIES = ( COMPARISON_OPERATOR, ALARM_DESCRIPTION, EVALUATION_PERIODS, METRIC_NAME, NAMESPACE, PERIOD, STATISTIC, ALARM_ACTIONS, OKACTIONS, DIMENSIONS, INSUFFICIENT_DATA_ACTIONS, THRESHOLD, UNITS, ) = ( 'ComparisonOperator', 'AlarmDescription', 'EvaluationPeriods', 'MetricName', 'Namespace', 'Period', 'Statistic', 'AlarmActions', 'OKActions', 'Dimensions', 'InsufficientDataActions', 'Threshold', 'Units', ) properties_schema = { COMPARISON_OPERATOR: properties.Schema( properties.Schema.STRING, _('Operator used to compare the specified Statistic with ' 'Threshold.'), constraints=[ constraints.AllowedValues(['GreaterThanOrEqualToThreshold', 'GreaterThanThreshold', 'LessThanThreshold', 'LessThanOrEqualToThreshold']), ], update_allowed=True ), ALARM_DESCRIPTION: properties.Schema( properties.Schema.STRING, _('Description for the alarm.'), update_allowed=True ), EVALUATION_PERIODS: properties.Schema( properties.Schema.STRING, _('Number of periods to evaluate over.'), update_allowed=True ), METRIC_NAME: properties.Schema( properties.Schema.STRING, _('Metric name watched by the alarm.') ), NAMESPACE: properties.Schema( properties.Schema.STRING, _('Namespace for the metric.') ), PERIOD: properties.Schema( properties.Schema.STRING, _('Period (seconds) to evaluate over.'), update_allowed=True ), STATISTIC: properties.Schema( properties.Schema.STRING, _('Metric statistic to evaluate.'), constraints=[ constraints.AllowedValues(['SampleCount', 'Average', 'Sum', 'Minimum', 'Maximum']), ], update_allowed=True ), ALARM_ACTIONS: properties.Schema( properties.Schema.LIST, _('A list of actions to execute when state transitions to alarm.'), update_allowed=True ), OKACTIONS: properties.Schema( properties.Schema.LIST, _('A list of actions to execute when state transitions to ok.'), update_allowed=True ), DIMENSIONS: properties.Schema( properties.Schema.LIST, _('A list of dimensions (arbitrary name/value pairs) associated ' 'with the metric.') ), INSUFFICIENT_DATA_ACTIONS: properties.Schema( properties.Schema.LIST, _('A list of actions to execute when state transitions to ' 'insufficient-data.'), update_allowed=True ), THRESHOLD: properties.Schema( properties.Schema.STRING, _('Threshold to evaluate against.'), update_allowed=True ), UNITS: properties.Schema( properties.Schema.STRING, _('Unit for the metric.'), constraints=[ constraints.AllowedValues(['Seconds', 'Microseconds', 'Milliseconds', 'Bytes', 'Kilobytes', 'Megabytes', 'Gigabytes', 'Terabytes', 'Bits', 'Kilobits', 'Megabits', 'Gigabits', 'Terabits', 'Percent', 'Count', 'Bytes/Second', 'Kilobytes/Second', 'Megabytes/Second', 'Gigabytes/Second', 'Terabytes/Second', 'Bits/Second', 'Kilobits/Second', 'Megabits/Second', 'Gigabits/Second', 'Terabits/Second', 'Count/Second', None]), ], update_allowed=True ), } strict_dependency = False update_allowed_keys = ('Properties',) def handle_create(self): wr = watchrule.WatchRule(context=self.context, watch_name=self.physical_resource_name(), rule=self.parsed_template('Properties'), stack_id=self.stack.id) wr.store() def handle_update(self, json_snippet, tmpl_diff, prop_diff): # If Properties has changed, update self.properties, so we # get the new values during any subsequent adjustment if prop_diff: self.properties = Properties(self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) loader = watchrule.WatchRule.load wr = loader(self.context, watch_name=self.physical_resource_name()) wr.rule = self.parsed_template('Properties') wr.store() def handle_delete(self): try: wr = watchrule.WatchRule.load( self.context, watch_name=self.physical_resource_name()) wr.destroy() except exception.WatchRuleNotFound: pass def handle_suspend(self): wr = watchrule.WatchRule.load(self.context, watch_name=self.physical_resource_name()) wr.state_set(wr.SUSPENDED) def handle_resume(self): wr = watchrule.WatchRule.load(self.context, watch_name=self.physical_resource_name()) # Just set to NODATA, which will be re-evaluated next periodic task wr.state_set(wr.NODATA) def FnGetRefId(self): return unicode(self.physical_resource_name()) def physical_resource_name(self): return '%s-%s' % (self.stack.name, self.name) def resource_mapping(): return { 'OS::Heat::CWLiteAlarm': CloudWatchAlarm, } heat-2014.1.5/heat/engine/resources/user.py0000664000567000056700000002561512540642614021572 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. from heat.common import exception from heat.db import api as db_api from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine import stack_user from heat.openstack.common import log as logging logger = logging.getLogger(__name__) # # We are ignoring Groups as keystone does not support them. # For now support users and accesskeys, # We also now support a limited heat-native Policy implementation # class User(stack_user.StackUser): PROPERTIES = ( PATH, GROUPS, LOGIN_PROFILE, POLICIES, ) = ( 'Path', 'Groups', 'LoginProfile', 'Policies', ) _LOGIN_PROFILE_KEYS = ( LOGIN_PROFILE_PASSWORD, ) = ( 'Password', ) properties_schema = { PATH: properties.Schema( properties.Schema.STRING, _('Not Implemented.') ), GROUPS: properties.Schema( properties.Schema.LIST, _('Not Implemented.') ), LOGIN_PROFILE: properties.Schema( properties.Schema.MAP, _('A login profile for the user.'), schema={ LOGIN_PROFILE_PASSWORD: properties.Schema( properties.Schema.STRING ), } ), POLICIES: properties.Schema( properties.Schema.LIST, _('Access policies to apply to the user.') ), } def _validate_policies(self, policies): for policy in (policies or []): # When we support AWS IAM style policies, we will have to accept # either a ref to an AWS::IAM::Policy defined in the stack, or # and embedded dict describing the policy directly, but for now # we only expect this list to contain strings, which must map # to an OS::Heat::AccessPolicy in this stack # If a non-string (e.g embedded IAM dict policy) is passed, we # ignore the policy (don't reject it because we previously ignored # and we don't want to break templates which previously worked if not isinstance(policy, basestring): logger.warning(_("Ignoring policy %s, must be string " "resource name") % policy) continue try: policy_rsrc = self.stack[policy] except KeyError: logger.error(_("Policy %(policy)s does not exist in stack " "%(stack)s") % { 'policy': policy, 'stack': self.stack.name}) return False if not callable(getattr(policy_rsrc, 'access_allowed', None)): logger.error(_("Policy %s is not an AccessPolicy resource") % policy) return False return True def handle_create(self): profile = self.properties[self.LOGIN_PROFILE] if profile and self.LOGIN_PROFILE_PASSWORD in profile: self.password = profile[self.LOGIN_PROFILE_PASSWORD] if self.properties[self.POLICIES]: if not self._validate_policies(self.properties[self.POLICIES]): raise exception.InvalidTemplateAttribute(resource=self.name, key=self.POLICIES) super(User, self).handle_create() self.resource_id_set(self._get_user_id()) def FnGetRefId(self): return unicode(self.physical_resource_name()) def access_allowed(self, resource_name): policies = (self.properties[self.POLICIES] or []) for policy in policies: if not isinstance(policy, basestring): logger.warning(_("Ignoring policy %s, must be string " "resource name") % policy) continue policy_rsrc = self.stack[policy] if not policy_rsrc.access_allowed(resource_name): return False return True class AccessKey(resource.Resource): PROPERTIES = ( SERIAL, USER_NAME, STATUS, ) = ( 'Serial', 'UserName', 'Status', ) properties_schema = { SERIAL: properties.Schema( properties.Schema.INTEGER, _('Not Implemented.'), implemented=False ), USER_NAME: properties.Schema( properties.Schema.STRING, _('The name of the user that the new key will belong to.'), required=True ), STATUS: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), constraints=[ constraints.AllowedValues(['Active', 'Inactive']), ], implemented=False ), } attributes_schema = { 'UserName': _('Username associated with the AccessKey.'), 'SecretAccessKey': _('Keypair secret key.'), } def __init__(self, name, json_snippet, stack): super(AccessKey, self).__init__(name, json_snippet, stack) self._secret = None if self.resource_id: self._register_access_key() def _get_user(self): """ Helper function to derive the keystone userid, which is stored in the resource_id of the User associated with this key. We want to avoid looking the name up via listing keystone users, as this requires admin rights in keystone, so FnGetAtt which calls _secret_accesskey won't work for normal non-admin users """ # Lookup User resource by intrinsic reference (which is what is passed # into the UserName parameter. Would be cleaner to just make the User # resource return resource_id for FnGetRefId but the AWS definition of # user does say it returns a user name not ID return self.stack.resource_by_refid(self.properties[self.USER_NAME]) def handle_create(self): user = self._get_user() if user is None: raise exception.NotFound(_('could not find user %s') % self.properties[self.USER_NAME]) # The keypair is actually created and owned by the User resource kp = user._create_keypair() self.resource_id_set(kp.access) self._secret = kp.secret self._register_access_key() # Store the secret key, encrypted, in the DB so we don't have lookup # the user every time someone requests the SecretAccessKey attribute db_api.resource_data_set(self, 'secret_key', kp.secret, redact=True) db_api.resource_data_set(self, 'credential_id', kp.id, redact=True) def handle_delete(self): self._secret = None if self.resource_id is None: return user = self._get_user() if user is None: logger.warning(_('Error deleting %s - user not found') % str(self)) return user._delete_keypair() def _secret_accesskey(self): ''' Return the user's access key, fetching it from keystone if necessary ''' if self._secret is None: if not self.resource_id: logger.warn(_('could not get secret for %(username)s ' 'Error:%(msg)s') % { 'username': self.properties[self.USER_NAME], 'msg': "resource_id not yet set"}) else: # First try to retrieve the secret from resource_data, but # for backwards compatibility, fall back to requesting from # keystone try: self._secret = db_api.resource_data_get(self, 'secret_key') except exception.NotFound: try: user_id = self._get_user().resource_id kp = self.keystone().get_ec2_keypair( user_id=user_id, access=self.resource_id) self._secret = kp.secret # Store the key in resource_data db_api.resource_data_set(self, 'secret_key', kp.secret, redact=True) # And the ID of the v3 credential db_api.resource_data_set(self, 'credential_id', kp.id, redact=True) except Exception as ex: logger.warn( _('could not get secret for %(username)s ' 'Error:%(msg)s') % { 'username': self.properties[self.USER_NAME], 'msg': str(ex)}) return self._secret or '000-000-000' def _resolve_attribute(self, name): if name == 'UserName': return self.properties[self.USER_NAME] elif name == 'SecretAccessKey': return self._secret_accesskey() def _register_access_key(self): def access_allowed(resource_name): return self._get_user().access_allowed(resource_name) self.stack.register_access_allowed_handler( self.resource_id, access_allowed) class AccessPolicy(resource.Resource): PROPERTIES = ( ALLOWED_RESOURCES, ) = ( 'AllowedResources', ) properties_schema = { ALLOWED_RESOURCES: properties.Schema( properties.Schema.LIST, _('Resources that users are allowed to access by the ' 'DescribeStackResource API.'), required=True ), } def handle_create(self): pass def validate(self): """Make sure all the AllowedResources are present.""" super(AccessPolicy, self).validate() resources = self.properties[self.ALLOWED_RESOURCES] # All of the provided resource names must exist in this stack for resource in resources: if resource not in self.stack: msg = _("AccessPolicy resource %s not in stack") % resource logger.error(msg) raise exception.StackValidationFailed(message=msg) def access_allowed(self, resource_name): return resource_name in self.properties[self.ALLOWED_RESOURCES] def resource_mapping(): return { 'AWS::IAM::User': User, 'AWS::IAM::AccessKey': AccessKey, 'OS::Heat::AccessPolicy': AccessPolicy, } heat-2014.1.5/heat/engine/resources/wait_condition.py0000664000567000056700000002534412540642614023625 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. import json from heat.common import identifier from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine import scheduler from heat.engine import signal_responder from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class WaitConditionHandle(signal_responder.SignalResponder): ''' the main point of this class is to : have no dependancies (so the instance can reference it) generate a unique url (to be returned in the reference) then the cfn-signal will use this url to post to and WaitCondition will poll it to see if has been written to. ''' properties_schema = {} def handle_create(self): super(WaitConditionHandle, self).handle_create() self.resource_id_set(self._get_user_id()) def FnGetRefId(self): ''' Override the default resource FnGetRefId so we return the signed URL ''' if self.resource_id: wc = signal_responder.WAITCONDITION return unicode(self._get_signed_url(signal_type=wc)) else: return unicode(self.name) def _metadata_format_ok(self, metadata): """ Check the format of the provided metadata is as expected. metadata must use the following format: { "Status" : "Status (must be SUCCESS or FAILURE)" "UniqueId" : "Some ID, should be unique for Count>1", "Data" : "Arbitrary Data", "Reason" : "Reason String" } """ expected_keys = ['Data', 'Reason', 'Status', 'UniqueId'] if sorted(metadata.keys()) == expected_keys: return metadata['Status'] in WAIT_STATUSES def metadata_update(self, new_metadata=None): ''' Validate and update the resource metadata ''' if new_metadata is None: return if self._metadata_format_ok(new_metadata): rsrc_metadata = self.metadata if new_metadata['UniqueId'] in rsrc_metadata: logger.warning(_("Overwriting Metadata item for UniqueId %s!") % new_metadata['UniqueId']) safe_metadata = {} for k in ('Data', 'Reason', 'Status'): safe_metadata[k] = new_metadata[k] # Note we can't update self.metadata directly, as it # is a Metadata descriptor object which only supports get/set rsrc_metadata.update({new_metadata['UniqueId']: safe_metadata}) self.metadata = rsrc_metadata else: logger.error(_("Metadata failed validation for %s") % self.name) raise ValueError(_("Metadata format invalid")) def get_status(self): ''' Return a list of the Status values for the handle signals ''' return [v['Status'] for v in self.metadata.values()] def get_status_reason(self, status): ''' Return the reason associated with a particular status If there is more than one handle signal matching the specified status then return a semicolon delimited string containing all reasons ''' return ';'.join([v['Reason'] for v in self.metadata.values() if v['Status'] == status]) WAIT_STATUSES = ( STATUS_FAILURE, STATUS_SUCCESS, ) = ( 'FAILURE', 'SUCCESS', ) class UpdateWaitConditionHandle(WaitConditionHandle): ''' This works identically to a regular WaitConditionHandle, except that on update it clears all signals received and changes the handle. Using this handle means that you must setup the signal senders to send their signals again any time the update handle changes. This allows us to roll out new configurations and be confident that they are rolled out once UPDATE COMPLETE is reached. ''' def update(self, after, before=None, prev_resource=None): raise resource.UpdateReplace(self.name) class WaitConditionFailure(Exception): def __init__(self, wait_condition, handle): reasons = handle.get_status_reason(STATUS_FAILURE) super(WaitConditionFailure, self).__init__(reasons) class WaitConditionTimeout(Exception): def __init__(self, wait_condition, handle): reasons = handle.get_status_reason(STATUS_SUCCESS) vals = {'len': len(reasons), 'count': wait_condition.properties[wait_condition.COUNT]} if reasons: vals['reasons'] = reasons message = (_('%(len)d of %(count)d received - %(reasons)s') % vals) else: message = (_('%(len)d of %(count)d received') % vals) super(WaitConditionTimeout, self).__init__(message) class WaitCondition(resource.Resource): PROPERTIES = ( HANDLE, TIMEOUT, COUNT, ) = ( 'Handle', 'Timeout', 'Count', ) properties_schema = { HANDLE: properties.Schema( properties.Schema.STRING, _('A reference to the wait condition handle used to signal this ' 'wait condition.'), required=True ), TIMEOUT: properties.Schema( properties.Schema.NUMBER, _('The number of seconds to wait for the correct number of ' 'signals to arrive.'), required=True, constraints=[ constraints.Range(1, 43200), ] ), COUNT: properties.Schema( properties.Schema.NUMBER, _('The number of success signals that must be received before ' 'the stack creation process continues.'), constraints=[ constraints.Range(min=1), ], default=1, update_allowed=True ), } attributes_schema = { 'Data': _('JSON serialized dict containing data associated with wait ' 'condition signals sent to the handle.'), } update_allowed_keys = ('Properties',) def __init__(self, name, json_snippet, stack): super(WaitCondition, self).__init__(name, json_snippet, stack) def _validate_handle_url(self): handle_url = self.properties[self.HANDLE] handle_id = identifier.ResourceIdentifier.from_arn_url(handle_url) if handle_id.tenant != self.stack.context.tenant_id: raise ValueError(_("WaitCondition invalid Handle tenant %s") % handle_id.tenant) if handle_id.stack_name != self.stack.name: raise ValueError(_("WaitCondition invalid Handle stack %s") % handle_id.stack_name) if handle_id.stack_id != self.stack.id: raise ValueError(_("WaitCondition invalid Handle stack %s") % handle_id.stack_id) if handle_id.resource_name not in self.stack: raise ValueError(_("WaitCondition invalid Handle %s") % handle_id.resource_name) if not isinstance(self.stack[handle_id.resource_name], WaitConditionHandle): raise ValueError(_("WaitCondition invalid Handle %s") % handle_id.resource_name) def _get_handle_resource_name(self): handle_url = self.properties[self.HANDLE] handle_id = identifier.ResourceIdentifier.from_arn_url(handle_url) return handle_id.resource_name def _wait(self, handle): while True: try: yield except scheduler.Timeout: timeout = WaitConditionTimeout(self, handle) logger.info(_('%(name)s Timed out (%(timeout)s)') % { 'name': str(self), 'timeout': str(timeout)}) raise timeout handle_status = handle.get_status() if any(s != STATUS_SUCCESS for s in handle_status): failure = WaitConditionFailure(self, handle) logger.info(_('%(name)s Failed (%(failure)s)') % { 'name': str(self), 'failure': str(failure)}) raise failure if len(handle_status) >= self.properties[self.COUNT]: logger.info(_("%s Succeeded") % str(self)) return def handle_create(self): self._validate_handle_url() handle_res_name = self._get_handle_resource_name() handle = self.stack[handle_res_name] self.resource_id_set(handle_res_name) runner = scheduler.TaskRunner(self._wait, handle) runner.start(timeout=float(self.properties[self.TIMEOUT])) return runner def check_create_complete(self, runner): return runner.step() def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: self.properties = properties.Properties( self.properties_schema, json_snippet.get('Properties', {}), self.stack.resolve_runtime_data, self.name, self.context) handle_res_name = self._get_handle_resource_name() handle = self.stack[handle_res_name] runner = scheduler.TaskRunner(self._wait, handle) runner.start(timeout=float(self.properties[self.TIMEOUT])) return runner def check_update_complete(self, runner): return runner.step() def handle_delete(self): if self.resource_id is None: return handle = self.stack[self.resource_id] handle.metadata = {} def _resolve_attribute(self, key): res = {} handle_res_name = self._get_handle_resource_name() handle = self.stack[handle_res_name] if key == 'Data': meta = handle.metadata # Note, can't use a dict generator on python 2.6, hence: res = dict([(k, meta[k]['Data']) for k in meta]) logger.debug(_('%(name)s.GetAtt(%(key)s) == %(res)s') % {'name': self.name, 'key': key, 'res': res}) return unicode(json.dumps(res)) def resource_mapping(): return { 'AWS::CloudFormation::WaitCondition': WaitCondition, 'AWS::CloudFormation::WaitConditionHandle': WaitConditionHandle, 'OS::Heat::UpdateWaitConditionHandle': UpdateWaitConditionHandle, } heat-2014.1.5/heat/engine/resources/subnet.py0000664000567000056700000001000412540642614022076 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. from heat.common import exception from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.engine.resources.vpc import VPC from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class Subnet(resource.Resource): PROPERTIES = ( AVAILABILITY_ZONE, CIDR_BLOCK, VPC_ID, TAGS, ) = ( 'AvailabilityZone', 'CidrBlock', 'VpcId', 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { AVAILABILITY_ZONE: properties.Schema( properties.Schema.STRING, _('Availability zone in which you want the subnet.') ), CIDR_BLOCK: properties.Schema( properties.Schema.STRING, _('CIDR block to apply to subnet.'), required=True ), VPC_ID: properties.Schema( properties.Schema.STRING, _('Ref structure that contains the ID of the VPC on which you ' 'want to create the subnet.'), required=True ), TAGS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, _('List of tags to attach to this resource.'), schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, implemented=False, ) ), } def handle_create(self): client = self.neutron() # TODO(sbaker) Verify that this CidrBlock is within the vpc CidrBlock network_id = self.properties.get(self.VPC_ID) props = { 'network_id': network_id, 'cidr': self.properties.get(self.CIDR_BLOCK), 'name': self.physical_resource_name(), 'ip_version': 4 } subnet = client.create_subnet({'subnet': props})['subnet'] router = VPC.router_for_vpc(self.neutron(), network_id) if router: client.add_interface_router( router['id'], {'subnet_id': subnet['id']}) self.resource_id_set(subnet['id']) def handle_delete(self): from neutronclient.common.exceptions import NeutronClientException client = self.neutron() network_id = self.properties.get(self.VPC_ID) subnet_id = self.resource_id try: router = VPC.router_for_vpc(self.neutron(), network_id) if router: client.remove_interface_router( router['id'], {'subnet_id': subnet_id}) except NeutronClientException as ex: if ex.status_code != 404: raise ex try: client.delete_subnet(subnet_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex def FnGetAtt(self, key): if key == 'AvailabilityZone': return self.properties.get(key) raise exception.InvalidTemplateAttribute(resource=self.name, key=key) def resource_mapping(): if clients.neutronclient is None: return {} return { 'AWS::EC2::Subnet': Subnet, } heat-2014.1.5/heat/engine/resources/random_string.py0000664000567000056700000000651012540642614023453 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. import random import string from six.moves import xrange from heat.db import api as db_api from heat.engine import constraints from heat.engine import properties from heat.engine import resource class RandomString(resource.Resource): ''' A resource which generates a random string. This is useful for configuring passwords and secrets on services. ''' PROPERTIES = ( LENGTH, SEQUENCE, SALT, ) = ( 'length', 'sequence', 'salt', ) properties_schema = { LENGTH: properties.Schema( properties.Schema.INTEGER, _('Length of the string to generate.'), default=32, constraints=[ constraints.Range(1, 512), ] ), SEQUENCE: properties.Schema( properties.Schema.STRING, _('Sequence of characters to build the random string from.'), default='lettersdigits', constraints=[ constraints.AllowedValues(['lettersdigits', 'letters', 'lowercase', 'uppercase', 'digits', 'hexdigits', 'octdigits']), ] ), SALT: properties.Schema( properties.Schema.STRING, _('Value which can be set or changed on stack update to trigger ' 'the resource for replacement with a new random string . The ' 'salt value itself is ignored by the random generator.') ), } attributes_schema = { 'value': _('The random string generated by this resource. This value ' 'is also available by referencing the resource.'), } _sequences = { 'lettersdigits': string.ascii_letters + string.digits, 'letters': string.ascii_letters, 'lowercase': string.ascii_lowercase, 'uppercase': string.ascii_uppercase, 'digits': string.digits, 'hexdigits': string.digits + 'ABCDEF', 'octdigits': string.octdigits } @staticmethod def _generate_random_string(sequence, length): rand = random.SystemRandom() return ''.join(rand.choice(sequence) for x in xrange(length)) def handle_create(self): length = self.properties.get(self.LENGTH) sequence = self._sequences[self.properties.get(self.SEQUENCE)] random_string = self._generate_random_string(sequence, length) db_api.resource_data_set(self, 'value', random_string, redact=True) self.resource_id_set(random_string) def _resolve_attribute(self, name): if name == 'value': return db_api.resource_data_get(self, 'value') def resource_mapping(): return { 'OS::Heat::RandomString': RandomString, } heat-2014.1.5/heat/engine/resources/internet_gateway.py0000664000567000056700000001120512540642614024153 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. from heat.common import exception from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.engine.resources import route_table from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class InternetGateway(resource.Resource): PROPERTIES = ( TAGS, ) = ( 'Tags', ) _TAG_KEYS = ( TAG_KEY, TAG_VALUE, ) = ( 'Key', 'Value', ) properties_schema = { TAGS: properties.Schema( properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, schema={ TAG_KEY: properties.Schema( properties.Schema.STRING, required=True ), TAG_VALUE: properties.Schema( properties.Schema.STRING, required=True ), }, implemented=False, ) ), } def handle_create(self): self.resource_id_set(self.physical_resource_name()) def handle_delete(self): pass @staticmethod def get_external_network_id(client): ext_filter = {'router:external': True} ext_nets = client.list_networks(**ext_filter)['networks'] if len(ext_nets) != 1: # TODO(sbaker) if there is more than one external network # add a heat configuration variable to set the ID of # the default one raise exception.Error( _('Expected 1 external network, found %d') % len(ext_nets)) external_network_id = ext_nets[0]['id'] return external_network_id class VPCGatewayAttachment(resource.Resource): PROPERTIES = ( VPC_ID, INTERNET_GATEWAY_ID, VPN_GATEWAY_ID, ) = ( 'VpcId', 'InternetGatewayId', 'VpnGatewayId', ) properties_schema = { VPC_ID: properties.Schema( properties.Schema.STRING, _('VPC ID for this gateway association.'), required=True ), INTERNET_GATEWAY_ID: properties.Schema( properties.Schema.STRING, _('ID of the InternetGateway.') ), VPN_GATEWAY_ID: properties.Schema( properties.Schema.STRING, _('ID of the VPNGateway to attach to the VPC.'), implemented=False ), } def _vpc_route_tables(self): for resource in self.stack.itervalues(): if (resource.has_interface('AWS::EC2::RouteTable') and resource.properties.get(route_table.RouteTable.VPC_ID) == self.properties.get(self.VPC_ID)): yield resource def add_dependencies(self, deps): super(VPCGatewayAttachment, self).add_dependencies(deps) # Depend on any route table in this template with the same # VpcId as this VpcId. # All route tables must exist before gateway attachment # as attachment happens to routers (not VPCs) for route_table in self._vpc_route_tables(): deps += (self, route_table) def handle_create(self): client = self.neutron() external_network_id = InternetGateway.get_external_network_id(client) for router in self._vpc_route_tables(): client.add_gateway_router(router.resource_id, { 'network_id': external_network_id}) def handle_delete(self): from neutronclient.common.exceptions import NeutronClientException client = self.neutron() for router in self._vpc_route_tables(): try: client.remove_gateway_router(router.resource_id) except NeutronClientException as ex: if ex.status_code != 404: raise ex def resource_mapping(): if clients.neutronclient is None: return {} return { 'AWS::EC2::InternetGateway': InternetGateway, 'AWS::EC2::VPCGatewayAttachment': VPCGatewayAttachment, } heat-2014.1.5/heat/engine/resources/os_database.py0000664000567000056700000002757012540642614023063 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. from heat.common import exception from heat.engine.clients import troveclient from heat.engine import constraints from heat.engine import properties from heat.engine import resource from heat.engine.resources import nova_utils from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class OSDBInstance(resource.Resource): ''' OpenStack cloud database instance resource. ''' PROPERTIES = ( NAME, FLAVOR, SIZE, DATABASES, USERS, AVAILABILITY_ZONE, RESTORE_POINT, ) = ( 'name', 'flavor', 'size', 'databases', 'users', 'availability_zone', 'restore_point', ) _DATABASE_KEYS = ( DATABASE_CHARACTER_SET, DATABASE_COLLATE, DATABASE_NAME, ) = ( 'character_set', 'collate', 'name', ) _USER_KEYS = ( USER_NAME, USER_PASSWORD, USER_HOST, USER_DATABASES, ) = ( 'name', 'password', 'host', 'databases', ) properties_schema = { NAME: properties.Schema( properties.Schema.STRING, _('Name of the DB instance to create.'), required=True, constraints=[ constraints.Length(max=255), ] ), FLAVOR: properties.Schema( properties.Schema.STRING, _('Reference to a flavor for creating DB instance.'), required=True ), SIZE: properties.Schema( properties.Schema.INTEGER, _('Database volume size in GB.'), required=True, constraints=[ constraints.Range(1, 150), ] ), DATABASES: properties.Schema( properties.Schema.LIST, _('List of databases to be created on DB instance creation.'), default=[], schema=properties.Schema( properties.Schema.MAP, schema={ DATABASE_CHARACTER_SET: properties.Schema( properties.Schema.STRING, _('Set of symbols and encodings.'), default='utf8' ), DATABASE_COLLATE: properties.Schema( properties.Schema.STRING, _('Set of rules for comparing characters in a ' 'character set.'), default='utf8_general_ci' ), DATABASE_NAME: properties.Schema( properties.Schema.STRING, _('Specifies database names for creating ' 'databases on instance creation.'), required=True, constraints=[ constraints.Length(max=64), constraints.AllowedPattern(r'[a-zA-Z0-9_]+' r'[a-zA-Z0-9_@?#\s]*' r'[a-zA-Z0-9_]+'), ] ), }, ) ), USERS: properties.Schema( properties.Schema.LIST, _('List of users to be created on DB instance creation.'), default=[], schema=properties.Schema( properties.Schema.MAP, schema={ USER_NAME: properties.Schema( properties.Schema.STRING, _('User name to create a user on instance ' 'creation.'), required=True, constraints=[ constraints.Length(max=16), constraints.AllowedPattern(r'[a-zA-Z0-9_]+' r'[a-zA-Z0-9_@?#\s]*' r'[a-zA-Z0-9_]+'), ] ), USER_PASSWORD: properties.Schema( properties.Schema.STRING, _('Password for those users on instance ' 'creation.'), required=True, constraints=[ constraints.AllowedPattern(r'[a-zA-Z0-9_]+' r'[a-zA-Z0-9_@?#\s]*' r'[a-zA-Z0-9_]+'), ] ), USER_HOST: properties.Schema( properties.Schema.STRING, _('The host from which a user is allowed to ' 'connect to the database.'), default='%' ), USER_DATABASES: properties.Schema( properties.Schema.LIST, _('Names of databases that those users can ' 'access on instance creation.'), schema=properties.Schema( properties.Schema.STRING, ), required=True ), }, ) ), AVAILABILITY_ZONE: properties.Schema( properties.Schema.STRING, _('Name of the availability zone for DB instance.') ), RESTORE_POINT: properties.Schema( properties.Schema.STRING, _('DB instance restore point.') ), } attributes_schema = { "hostname": _("Hostname of the instance"), "href": _("Api endpoint reference of the instance") } def __init__(self, name, json_snippet, stack): super(OSDBInstance, self).__init__(name, json_snippet, stack) self._href = None self._dbinstance = None @property def dbinstance(self): """Get the trove dbinstance.""" if not self._dbinstance and self.resource_id: self._dbinstance = self.trove().instances.get(self.resource_id) return self._dbinstance def physical_resource_name(self): name = self.properties.get(self.NAME) if name: return name return super(OSDBInstance, self).physical_resource_name() def handle_create(self): ''' Create cloud database instance. ''' self.dbinstancename = self.physical_resource_name() self.flavor = nova_utils.get_flavor_id(self.trove(), self.properties[self.FLAVOR]) self.volume = {'size': self.properties[self.SIZE]} self.databases = self.properties.get(self.DATABASES) self.users = self.properties.get(self.USERS) restore_point = self.properties.get(self.RESTORE_POINT) zone = self.properties.get(self.AVAILABILITY_ZONE) # convert user databases to format required for troveclient. # that is, list of database dictionaries for user in self.users: dbs = [{'name': db} for db in user.get(self.USER_DATABASES, [])] user[self.USER_DATABASES] = dbs # create db instance instance = self.trove().instances.create( self.dbinstancename, self.flavor, volume=self.volume, databases=self.databases, users=self.users, restorePoint=restore_point, availability_zone=zone) self.resource_id_set(instance.id) return instance def _refresh_instance(self, instance): try: instance.get() except troveclient.exceptions.RequestEntityTooLarge as exc: msg = _("Stack %(name)s (%(id)s) received an OverLimit " "response during instance.get(): %(exception)s") logger.warning(msg % {'name': self.stack.name, 'id': self.stack.id, 'exception': str(exc)}) def check_create_complete(self, instance): ''' Check if cloud DB instance creation is complete. ''' self._refresh_instance(instance) if instance.status == 'ERROR': raise exception.Error(_("Database instance creation failed.")) if instance.status != 'ACTIVE': return False msg = _("Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)") logger.info(msg % ({'database': self.dbinstancename, 'flavor': self.flavor, 'volume': self.volume})) return True def handle_delete(self): ''' Delete a cloud database instance. ''' if not self.resource_id: return instance = None try: instance = self.trove().instances.get(self.resource_id) except troveclient.exceptions.NotFound: logger.debug(_("Database instance %s not found.") % self.resource_id) self.resource_id_set(None) else: instance.delete() return instance def check_delete_complete(self, instance): ''' Check for completion of cloud DB instance delettion ''' if not instance: return True try: self._refresh_instance(instance) except troveclient.exceptions.NotFound: self.resource_id_set(None) return True return False def validate(self): ''' Validate any of the provided params ''' res = super(OSDBInstance, self).validate() if res: return res # check validity of user and databases users = self.properties.get(self.USERS) if not users: return databases = self.properties.get(self.DATABASES) if not databases: msg = _('Databases property is required if users property' ' is provided') raise exception.StackValidationFailed(message=msg) db_names = set([db[self.DATABASE_NAME] for db in databases]) for user in users: if not user.get(self.USER_DATABASES, []): msg = _('Must provide access to at least one database for ' 'user %s') % user[self.USER_NAME] raise exception.StackValidationFailed(message=msg) missing_db = [db_name for db_name in user[self.USER_DATABASES] if db_name not in db_names] if missing_db: msg = _('Database %s specified for user does not exist in ' 'databases.') % missing_db raise exception.StackValidationFailed(message=msg) def href(self): if not self._href and self.dbinstance: if not self.dbinstance.links: self._href = None else: for link in self.dbinstance.links: if link['rel'] == 'self': self._href = link['href'] break return self._href def _resolve_attribute(self, name): if name == 'hostname': return self.dbinstance.hostname elif name == 'href': return self.href() def resource_mapping(): return { 'OS::Trove::Instance': OSDBInstance, } heat-2014.1.5/heat/engine/resources/loadbalancer.py0000664000567000056700000004400712540642614023217 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. import os from oslo.config import cfg from heat.common import exception from heat.common import template_format from heat.engine import constraints from heat.engine import properties from heat.engine.resources import nova_utils from heat.engine import stack_resource from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) lb_template_default = r''' { "AWSTemplateFormatVersion": "2010-09-09", "Description": "Built in HAProxy server", "Parameters" : { "KeyName" : { "Type" : "String" } }, "Resources": { "latency_watcher": { "Type": "AWS::CloudWatch::Alarm", "Properties": { "MetricName": "Latency", "Namespace": "AWS/ELB", "Statistic": "Average", "Period": "60", "EvaluationPeriods": "1", "Threshold": "2", "AlarmActions": [], "ComparisonOperator": "GreaterThanThreshold" } }, "CfnLBUser" : { "Type" : "AWS::IAM::User" }, "CfnLBAccessKey" : { "Type" : "AWS::IAM::AccessKey", "Properties" : { "UserName" : {"Ref": "CfnLBUser"} } }, "LB_instance": { "Type": "AWS::EC2::Instance", "Metadata": { "AWS::CloudFormation::Init": { "config": { "packages": { "yum": { "cronie" : [], "haproxy" : [], "socat" : [], "python-psutil" : [] } }, "services": { "systemd": { "crond" : { "enabled" : "true", "ensureRunning" : "true" } } }, "files": { "/etc/cfn/cfn-credentials" : { "content" : { "Fn::Join" : ["", [ "AWSAccessKeyId=", { "Ref" : "CfnLBAccessKey" }, "\n", "AWSSecretKey=", {"Fn::GetAtt": ["CfnLBAccessKey", "SecretAccessKey"]}, "\n" ]]}, "mode" : "000400", "owner" : "root", "group" : "root" }, "/etc/cfn/cfn-hup.conf" : { "content" : { "Fn::Join" : ["", [ "[main]\n", "stack=", { "Ref" : "AWS::StackId" }, "\n", "credential-file=/etc/cfn/cfn-credentials\n", "region=", { "Ref" : "AWS::Region" }, "\n", "interval=60\n" ]]}, "mode" : "000400", "owner" : "root", "group" : "root" }, "/etc/cfn/hooks.conf" : { "content": { "Fn::Join" : ["", [ "[cfn-init]\n", "triggers=post.update\n", "path=Resources.LB_instance.Metadata\n", "action=/opt/aws/bin/cfn-init -s ", { "Ref": "AWS::StackId" }, " -r LB_instance ", " --region ", { "Ref": "AWS::Region" }, "\n", "runas=root\n", "\n", "[reload]\n", "triggers=post.update\n", "path=Resources.LB_instance.Metadata\n", "action=systemctl reload-or-restart haproxy.service\n", "runas=root\n" ]]}, "mode" : "000400", "owner" : "root", "group" : "root" }, "/etc/haproxy/haproxy.cfg": { "content": "", "mode": "000644", "owner": "root", "group": "root" }, "/tmp/cfn-hup-crontab.txt" : { "content" : { "Fn::Join" : ["", [ "MAIL=\"\"\n", "\n", "* * * * * /opt/aws/bin/cfn-hup -f\n", "* * * * * /opt/aws/bin/cfn-push-stats ", " --watch ", { "Ref" : "latency_watcher" }, " --haproxy\n" ]]}, "mode" : "000600", "owner" : "root", "group" : "root" } } } } }, "Properties": { "ImageId": "F20-x86_64-cfntools", "InstanceType": "m1.small", "KeyName": { "Ref": "KeyName" }, "UserData": { "Fn::Base64": { "Fn::Join": ["", [ "#!/bin/bash -v\n", "# Helper function\n", "function error_exit\n", "{\n", " /opt/aws/bin/cfn-signal -e 1 -r \"$1\" '", { "Ref" : "WaitHandle" }, "'\n", " exit 1\n", "}\n", "/opt/aws/bin/cfn-init -s ", { "Ref": "AWS::StackId" }, " -r LB_instance ", " --region ", { "Ref": "AWS::Region" }, "\n", "# install cfn-hup crontab\n", "crontab /tmp/cfn-hup-crontab.txt\n", "# LB setup completed, signal success\n", "/opt/aws/bin/cfn-signal -e 0 -r \"LB server setup complete\" '", { "Ref" : "WaitHandle" }, "'\n" ]]}} } }, "WaitHandle" : { "Type" : "AWS::CloudFormation::WaitConditionHandle" }, "WaitCondition" : { "Type" : "AWS::CloudFormation::WaitCondition", "DependsOn" : "LB_instance", "Properties" : { "Handle" : {"Ref" : "WaitHandle"}, "Timeout" : "600" } } }, "Outputs": { "PublicIp": { "Value": { "Fn::GetAtt": [ "LB_instance", "PublicIp" ] }, "Description": "instance IP" } } } ''' # Allow user to provide alternative nested stack template to the above loadbalancer_opts = [ cfg.StrOpt('loadbalancer_template', default=None, help='Custom template for the built-in ' 'loadbalancer nested stack.')] cfg.CONF.register_opts(loadbalancer_opts) class LoadBalancer(stack_resource.StackResource): PROPERTIES = ( AVAILABILITY_ZONES, HEALTH_CHECK, INSTANCES, LISTENERS, APP_COOKIE_STICKINESS_POLICY, LBCOOKIE_STICKINESS_POLICY, SECURITY_GROUPS, SUBNETS, ) = ( 'AvailabilityZones', 'HealthCheck', 'Instances', 'Listeners', 'AppCookieStickinessPolicy', 'LBCookieStickinessPolicy', 'SecurityGroups', 'Subnets', ) _HEALTH_CHECK_KEYS = ( HEALTH_CHECK_HEALTHY_THRESHOLD, HEALTH_CHECK_INTERVAL, HEALTH_CHECK_TARGET, HEALTH_CHECK_TIMEOUT, HEALTH_CHECK_UNHEALTHY_THRESHOLD, ) = ( 'HealthyThreshold', 'Interval', 'Target', 'Timeout', 'UnhealthyThreshold', ) _LISTENER_KEYS = ( LISTENER_INSTANCE_PORT, LISTENER_LOAD_BALANCER_PORT, LISTENER_PROTOCOL, LISTENER_SSLCERTIFICATE_ID, LISTENER_POLICY_NAMES, ) = ( 'InstancePort', 'LoadBalancerPort', 'Protocol', 'SSLCertificateId', 'PolicyNames', ) properties_schema = { AVAILABILITY_ZONES: properties.Schema( properties.Schema.LIST, _('The Availability Zones in which to create the load balancer.'), required=True ), HEALTH_CHECK: properties.Schema( properties.Schema.MAP, _('An application health check for the instances.'), schema={ HEALTH_CHECK_HEALTHY_THRESHOLD: properties.Schema( properties.Schema.NUMBER, _('The number of consecutive health probe successes ' 'required before moving the instance to the ' 'healthy state.'), required=True ), HEALTH_CHECK_INTERVAL: properties.Schema( properties.Schema.NUMBER, _('The approximate interval, in seconds, between ' 'health checks of an individual instance.'), required=True ), HEALTH_CHECK_TARGET: properties.Schema( properties.Schema.STRING, _('The port being checked.'), required=True ), HEALTH_CHECK_TIMEOUT: properties.Schema( properties.Schema.NUMBER, _('Health probe timeout, in seconds.'), required=True ), HEALTH_CHECK_UNHEALTHY_THRESHOLD: properties.Schema( properties.Schema.NUMBER, _('The number of consecutive health probe failures ' 'required before moving the instance to the ' 'unhealthy state'), required=True ), } ), INSTANCES: properties.Schema( properties.Schema.LIST, _('The list of instance IDs load balanced.'), update_allowed=True ), LISTENERS: properties.Schema( properties.Schema.LIST, _('One or more listeners for this load balancer.'), schema=properties.Schema( properties.Schema.MAP, schema={ LISTENER_INSTANCE_PORT: properties.Schema( properties.Schema.NUMBER, _('TCP port on which the instance server is ' 'listening.'), required=True ), LISTENER_LOAD_BALANCER_PORT: properties.Schema( properties.Schema.NUMBER, _('The external load balancer port number.'), required=True ), LISTENER_PROTOCOL: properties.Schema( properties.Schema.STRING, _('The load balancer transport protocol to use.'), required=True, constraints=[ constraints.AllowedValues(['TCP', 'HTTP']), ] ), LISTENER_SSLCERTIFICATE_ID: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), LISTENER_POLICY_NAMES: properties.Schema( properties.Schema.LIST, _('Not Implemented.'), implemented=False ), }, ), required=True ), APP_COOKIE_STICKINESS_POLICY: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), LBCOOKIE_STICKINESS_POLICY: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), SECURITY_GROUPS: properties.Schema( properties.Schema.STRING, _('Not Implemented.'), implemented=False ), SUBNETS: properties.Schema( properties.Schema.LIST, _('Not Implemented.'), implemented=False ), } attributes_schema = { "CanonicalHostedZoneName": _("The name of the hosted zone that is " "associated with the LoadBalancer."), "CanonicalHostedZoneNameID": _("The ID of the hosted zone name " "that is associated with the " "LoadBalancer."), "DNSName": _("The DNS name for the LoadBalancer."), "SourceSecurityGroup.GroupName": _("The security group that you can " "use as part of your inbound " "rules for your LoadBalancer's " "back-end instances."), "SourceSecurityGroup.OwnerAlias": _("Owner of the source " "security group.") } update_allowed_keys = ('Properties',) def _haproxy_config(self, templ, instances): # initial simplifications: # - only one Listener # - only http (no tcp or ssl) # # option httpchk HEAD /check.txt HTTP/1.0 gl = ''' global daemon maxconn 256 stats socket /tmp/.haproxy-stats defaults mode http timeout connect 5000ms timeout client 50000ms timeout server 50000ms ''' listener = self.properties[self.LISTENERS][0] lb_port = listener[self.LISTENER_LOAD_BALANCER_PORT] inst_port = listener[self.LISTENER_INSTANCE_PORT] spaces = ' ' frontend = ''' frontend http bind *:%s ''' % (lb_port) health_chk = self.properties[self.HEALTH_CHECK] if health_chk: check = 'check inter %ss fall %s rise %s' % ( health_chk[self.HEALTH_CHECK_INTERVAL], health_chk[self.HEALTH_CHECK_UNHEALTHY_THRESHOLD], health_chk[self.HEALTH_CHECK_HEALTHY_THRESHOLD]) timeout = int(health_chk[self.HEALTH_CHECK_TIMEOUT]) timeout_check = 'timeout check %ds' % timeout else: check = '' timeout_check = '' backend = ''' default_backend servers backend servers balance roundrobin option http-server-close option forwardfor option httpchk %s ''' % timeout_check servers = [] n = 1 client = self.nova() for i in instances: ip = nova_utils.server_to_ipaddress(client, i) or '0.0.0.0' logger.debug(_('haproxy server:%s') % ip) servers.append('%sserver server%d %s:%s %s' % (spaces, n, ip, inst_port, check)) n = n + 1 return '%s%s%s%s\n' % (gl, frontend, backend, '\n'.join(servers)) def get_parsed_template(self): if cfg.CONF.loadbalancer_template: with open(cfg.CONF.loadbalancer_template) as templ_fd: logger.info(_('Using custom loadbalancer template %s') % cfg.CONF.loadbalancer_template) contents = templ_fd.read() else: contents = lb_template_default return template_format.parse(contents) def child_params(self): params = {} # If the owning stack defines KeyName, we use that key for the nested # template, otherwise use no key if 'KeyName' in self.stack.parameters: params['KeyName'] = self.stack.parameters['KeyName'] return params def child_template(self): templ = self.get_parsed_template() # If the owning stack defines KeyName, we use that key for the nested # template, otherwise use no key if 'KeyName' not in self.stack.parameters: del templ['Resources']['LB_instance']['Properties']['KeyName'] del templ['Parameters']['KeyName'] return templ def handle_create(self): templ = self.child_template() params = self.child_params() if self.properties[self.INSTANCES]: md = templ['Resources']['LB_instance']['Metadata'] files = md['AWS::CloudFormation::Init']['config']['files'] cfg = self._haproxy_config(templ, self.properties[self.INSTANCES]) files['/etc/haproxy/haproxy.cfg']['content'] = cfg return self.create_with_template(templ, params) def handle_update(self, json_snippet, tmpl_diff, prop_diff): ''' re-generate the Metadata save it to the db. rely on the cfn-hup to reconfigure HAProxy ''' if self.INSTANCES in prop_diff: templ = self.get_parsed_template() cfg = self._haproxy_config(templ, prop_diff[self.INSTANCES]) md = self.nested()['LB_instance'].metadata files = md['AWS::CloudFormation::Init']['config']['files'] files['/etc/haproxy/haproxy.cfg']['content'] = cfg self.nested()['LB_instance'].metadata = md def handle_delete(self): return self.delete_nested() def validate(self): ''' Validate any of the provided params ''' res = super(LoadBalancer, self).validate() if res: return res if cfg.CONF.loadbalancer_template and \ not os.access(cfg.CONF.loadbalancer_template, os.R_OK): msg = _('Custom LoadBalancer template can not be found') raise exception.StackValidationFailed(message=msg) health_chk = self.properties[self.HEALTH_CHECK] if health_chk: interval = float(health_chk[self.HEALTH_CHECK_INTERVAL]) timeout = float(health_chk[self.HEALTH_CHECK_TIMEOUT]) if interval < timeout: return {'Error': 'Interval must be larger than Timeout'} def FnGetRefId(self): return unicode(self.name) def _resolve_attribute(self, name): ''' We don't really support any of these yet. ''' if name == 'DNSName': return self.get_output('PublicIp') elif name in self.attributes_schema: # Not sure if we should return anything for the other attribs # since they aren't really supported in any meaningful way return '' def resource_mapping(): return { 'AWS::ElasticLoadBalancing::LoadBalancer': LoadBalancer, } heat-2014.1.5/heat/engine/resources/nova_floatingip.py0000664000567000056700000001025512540642614023765 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. from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.openstack.common import excutils from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class NovaFloatingIp(resource.Resource): PROPERTIES = (POOL,) = ('pool',) properties_schema = { POOL: properties.Schema( properties.Schema.STRING, description=_('Allocate a floating IP from a given ' 'floating IP pool.') ), } attributes_schema = { 'pool': _('Pool from which floating IP is allocated.'), 'ip': _('Allocated floating IP address.') } def __init__(self, name, json_snippet, stack): super(NovaFloatingIp, self).__init__(name, json_snippet, stack) self._floating_ip = None def _get_resource(self): if self._floating_ip is None and self.resource_id is not None: self._floating_ip = self.nova().floating_ips.get(self.resource_id) return self._floating_ip def handle_create(self): try: pool = self.properties.get(self.POOL) floating_ip = self.nova().floating_ips.create(pool=pool) except clients.novaclient.exceptions.NotFound: with excutils.save_and_reraise_exception(): if pool is None: msg = _('Could not allocate floating IP. Probably there ' 'is no default floating IP pool is configured.') logger.error(msg) self.resource_id_set(floating_ip.id) self._floating_ip = floating_ip def handle_delete(self): if self.resource_id is not None: try: self.nova().floating_ips.delete(self.resource_id) except clients.novaclient.exceptions.NotFound: pass def _resolve_attribute(self, key): floating_ip = self._get_resource() attributes = { 'pool': getattr(floating_ip, 'pool', None), 'ip': floating_ip.ip } return unicode(attributes[key]) class NovaFloatingIpAssociation(resource.Resource): PROPERTIES = ( SERVER, FLOATING_IP ) = ( 'server_id', 'floating_ip' ) properties_schema = { SERVER: properties.Schema( properties.Schema.STRING, _('Server to assign floating IP to.'), required=True ), FLOATING_IP: properties.Schema( properties.Schema.STRING, _('ID of the floating IP to assign to the server.'), required=True ), } def FnGetRefId(self): return unicode(self.physical_resource_name()) def handle_create(self): server = self.nova().servers.get(self.properties[self.SERVER]) fl_ip = self.nova().floating_ips.get(self.properties[self.FLOATING_IP]) self.nova().servers.add_floating_ip(server, fl_ip.ip) self.resource_id_set('%s-%s' % (fl_ip.id, fl_ip.ip)) def handle_delete(self): if self.resource_id is None: return try: server = self.nova().servers.get(self.properties[self.SERVER]) if server: fl_ip = self.nova().floating_ips.\ get(self.properties[self.FLOATING_IP]) self.nova().servers.remove_floating_ip(server, fl_ip.ip) except clients.novaclient.exceptions.NotFound: pass def resource_mapping(): return { 'OS::Nova::FloatingIP': NovaFloatingIp, 'OS::Nova::FloatingIPAssociation': NovaFloatingIpAssociation, } heat-2014.1.5/heat/engine/service.py0000664000567000056700000013242012540642614020233 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. import functools import json from oslo.config import cfg import webob cfg.CONF.import_opt('engine_life_check_timeout', 'heat.common.config') cfg.CONF.import_opt('max_resources_per_stack', 'heat.common.config') cfg.CONF.import_opt('max_stacks_per_tenant', 'heat.common.config') from heat.openstack.common import timeutils from heat.common import context from heat.db import api as db_api from heat.engine import api from heat.rpc import api as rpc_api from heat.engine import attributes from heat.engine import clients from heat.engine.event import Event from heat.engine import environment from heat.common import exception from heat.common import identifier from heat.common import heat_keystoneclient as hkc from heat.engine import parameter_groups from heat.engine import parser from heat.engine import properties from heat.engine import resource from heat.engine import resources from heat.engine import stack_lock from heat.engine import watchrule from heat.openstack.common import log as logging from heat.openstack.common import threadgroup from heat.openstack.common.gettextutils import _ from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common.rpc import proxy from heat.openstack.common.rpc import service from heat.openstack.common import excutils from heat.openstack.common import uuidutils logger = logging.getLogger(__name__) def request_context(func): @functools.wraps(func) def wrapped(self, ctx, *args, **kwargs): if ctx is not None and not isinstance(ctx, context.RequestContext): ctx = context.RequestContext.from_dict(ctx.to_dict()) try: return func(self, ctx, *args, **kwargs) except exception.HeatException: raise rpc_common.ClientException() return wrapped class ThreadGroupManager(object): def __init__(self): super(ThreadGroupManager, self).__init__() self.groups = {} # Create dummy service task, because when there is nothing queued # on self.tg the process exits self.add_timer(cfg.CONF.periodic_interval, self._service_task) def _service_task(self): """ This is a dummy task which gets queued on the service.Service threadgroup. Without this service.Service sees nothing running i.e has nothing to wait() on, so the process exits.. This could also be used to trigger periodic non-stack-specific housekeeping tasks """ pass def start(self, stack_id, func, *args, **kwargs): """ Run the given method in a sub-thread. """ if stack_id not in self.groups: self.groups[stack_id] = threadgroup.ThreadGroup() return self.groups[stack_id].add_thread(func, *args, **kwargs) def start_with_lock(self, cnxt, stack, engine_id, func, *args, **kwargs): """ Try to acquire a stack lock and, if successful, run the given method in a sub-thread. Release the lock when the thread finishes. :param cnxt: RPC context :param stack: Stack to be operated on :type stack: heat.engine.parser.Stack :param engine_id: The UUID of the engine acquiring the lock :param func: Callable to be invoked in sub-thread :type func: function or instancemethod :param args: Args to be passed to func :param kwargs: Keyword-args to be passed to func. """ lock = stack_lock.StackLock(cnxt, stack, engine_id) lock.acquire() self.start_with_acquired_lock(stack, lock, func, *args, **kwargs) def start_with_acquired_lock(self, stack, lock, func, *args, **kwargs): """ Run the given method in a sub-thread and release the provided lock when the thread finishes. :param stack: Stack to be operated on :type stack: heat.engine.parser.Stack :param lock: The acquired stack lock :type lock: heat.engine.stack_lock.StackLock :param func: Callable to be invoked in sub-thread :type func: function or instancemethod :param args: Args to be passed to func :param kwargs: Keyword-args to be passed to func """ def release(gt, *args): """ Callback function that will be passed to GreenThread.link(). """ lock.release(*args) try: th = self.start(stack.id, func, *args, **kwargs) th.link(release, stack.id) except: with excutils.save_and_reraise_exception(): lock.release(stack.id) def add_timer(self, stack_id, func, *args, **kwargs): """ Define a periodic task, to be run in a separate thread, in the stack threadgroups. Periodicity is cfg.CONF.periodic_interval """ if stack_id not in self.groups: self.groups[stack_id] = threadgroup.ThreadGroup() self.groups[stack_id].add_timer(cfg.CONF.periodic_interval, func, *args, **kwargs) def stop_timers(self, stack_id): if stack_id in self.groups: self.groups[stack_id].stop_timers() def stop(self, stack_id): '''Stop any active threads on a stack.''' if stack_id in self.groups: self.groups[stack_id].stop() del self.groups[stack_id] class StackWatch(object): def __init__(self, thread_group_mgr): self.thread_group_mgr = thread_group_mgr def start_watch_task(self, stack_id, cnxt): def stack_has_a_watchrule(sid): wrs = db_api.watch_rule_get_all_by_stack(cnxt, sid) now = timeutils.utcnow() start_watch_thread = False for wr in wrs: # reset the last_evaluated so we don't fire off alarms when # the engine has not been running. db_api.watch_rule_update(cnxt, wr.id, {'last_evaluated': now}) if wr.state != rpc_api.WATCH_STATE_CEILOMETER_CONTROLLED: start_watch_thread = True children = db_api.stack_get_all_by_owner_id(cnxt, sid) for child in children: if stack_has_a_watchrule(child.id): start_watch_thread = True return start_watch_thread if stack_has_a_watchrule(stack_id): self.thread_group_mgr.add_timer( stack_id, self.periodic_watcher_task, sid=stack_id) def check_stack_watches(self, sid): # Retrieve the stored credentials & create context # Require tenant_safe=False to the stack_get to defeat tenant # scoping otherwise we fail to retrieve the stack logger.debug(_("Periodic watcher task for stack %s") % sid) admin_context = context.get_admin_context() stack = db_api.stack_get(admin_context, sid, tenant_safe=False) if not stack: logger.error(_("Unable to retrieve stack %s for periodic task") % sid) return stack_context = EngineService.load_user_creds(stack.user_creds_id) # recurse into any nested stacks. children = db_api.stack_get_all_by_owner_id(admin_context, sid) for child in children: self.check_stack_watches(child.id) # Get all watchrules for this stack and evaluate them try: wrs = db_api.watch_rule_get_all_by_stack(stack_context, sid) except Exception as ex: logger.warn(_('periodic_task db error (%(msg)s) %(ex)s') % { 'msg': 'watch rule removed?', 'ex': str(ex)}) return def run_alarm_action(actions, details): for action in actions: action(details=details) stk = parser.Stack.load(stack_context, stack=stack) for res in stk.itervalues(): res.metadata_update() for wr in wrs: rule = watchrule.WatchRule.load(stack_context, watch=wr) actions = rule.evaluate() if actions: self.thread_group_mgr.start(sid, run_alarm_action, actions, rule.get_details()) def periodic_watcher_task(self, sid): """ Periodic task, created for each stack, triggers watch-rule evaluation for all rules defined for the stack sid = stack ID """ self.check_stack_watches(sid) class EngineListener(service.Service): ''' Listen on an AMQP queue named for the engine. Allows individual engines to communicate with each other for multi-engine support. ''' def __init__(self, host, engine_id, thread_group_mgr): super(EngineListener, self).__init__(host, engine_id) self.thread_group_mgr = thread_group_mgr self.engine_id = engine_id def listening(self, ctxt): ''' Respond affirmatively to confirm that the engine performing the action is still alive. ''' return True def stop_stack(self, ctxt, stack_identity): '''Stop any active threads on a stack.''' stack_id = stack_identity['stack_id'] self.thread_group_mgr.stop(stack_id) class EngineService(service.Service): """ Manages the running instances from creation to destruction. All the methods in here are called from the RPC backend. This is all done dynamically so if a call is made via RPC that does not have a corresponding method here, an exception will be thrown when it attempts to call into this class. Arguments to these methods are also dynamically added and will be named as keyword arguments by the RPC caller. """ RPC_API_VERSION = '1.1' def __init__(self, host, topic, manager=None): super(EngineService, self).__init__(host, topic) resources.initialise() self.engine_id = stack_lock.StackLock.generate_engine_id() self.thread_group_mgr = ThreadGroupManager() self.stack_watch = StackWatch(self.thread_group_mgr) self.listener = EngineListener(host, self.engine_id, self.thread_group_mgr) logger.debug(_("Starting listener for engine %s") % self.engine_id) self.listener.start() def start(self): super(EngineService, self).start() # Create a periodic_watcher_task per-stack admin_context = context.get_admin_context() stacks = db_api.stack_get_all(admin_context, tenant_safe=False) for s in stacks: self.stack_watch.start_watch_task(s.id, admin_context) @staticmethod def load_user_creds(creds_id): user_creds = db_api.user_creds_get(creds_id) stored_context = context.RequestContext.from_dict(user_creds) # heat_keystoneclient populates the context with an auth_token # either via the stored user/password or trust_id, depending # on how deferred_auth_method is configured in the conf file hkc.KeystoneClient(stored_context) return stored_context @request_context def identify_stack(self, cnxt, stack_name): """ The identify_stack method returns the full stack identifier for a single, live stack given the stack name. :param cnxt: RPC context. :param stack_name: Name or UUID of the stack to look up. """ if uuidutils.is_uuid_like(stack_name): s = db_api.stack_get(cnxt, stack_name, show_deleted=True) # may be the name is in uuid format, so if get by id returns None, # we should get the info by name again if not s: s = db_api.stack_get_by_name(cnxt, stack_name) else: s = db_api.stack_get_by_name(cnxt, stack_name) if s: stack = parser.Stack.load(cnxt, stack=s) return dict(stack.identifier()) else: raise exception.StackNotFound(stack_name=stack_name) def _get_stack(self, cnxt, stack_identity, show_deleted=False): identity = identifier.HeatIdentifier(**stack_identity) s = db_api.stack_get(cnxt, identity.stack_id, show_deleted=show_deleted) if s is None: raise exception.StackNotFound(stack_name=identity.stack_name) if cnxt.tenant_id not in (identity.tenant, s.stack_user_project_id): # The DB API should not allow this, but sanity-check anyway.. raise exception.InvalidTenant(target=identity.tenant, actual=cnxt.tenant_id) if identity.path or s.name != identity.stack_name: raise exception.StackNotFound(stack_name=identity.stack_name) return s @request_context def show_stack(self, cnxt, stack_identity): """ Return detailed information about one or all stacks. :param cnxt: RPC context. :param stack_identity: Name of the stack you want to show, or None to show all """ if stack_identity is not None: stacks = [self._get_stack(cnxt, stack_identity, show_deleted=True)] else: stacks = db_api.stack_get_all(cnxt) or [] def format_stack_detail(s): stack = parser.Stack.load(cnxt, stack=s) return api.format_stack(stack) return [format_stack_detail(s) for s in stacks] def get_revision(self, cnxt): return cfg.CONF.revision['heat_revision'] @request_context def list_stacks(self, cnxt, limit=None, marker=None, sort_keys=None, sort_dir=None, filters=None, tenant_safe=True): """ The list_stacks method returns attributes of all stacks. It supports pagination (``limit`` and ``marker``), sorting (``sort_keys`` and ``sort_dir``) and filtering (``filters``) of the results. :param cnxt: RPC context :param limit: the number of stacks to list (integer or string) :param marker: the ID of the last item in the previous page :param sort_keys: an array of fields used to sort the list :param sort_dir: the direction of the sort ('asc' or 'desc') :param filters: a dict with attribute:value to filter the list :param tenant_safe: if true, scope the request by the current tenant :returns: a list of formatted stacks """ def format_stack_details(stacks): for s in stacks: try: stack = parser.Stack.load(cnxt, stack=s, resolve_data=False) except exception.NotFound: # The stack may have been deleted between listing # and formatting pass else: yield api.format_stack(stack) stacks = db_api.stack_get_all(cnxt, limit, sort_keys, marker, sort_dir, filters, tenant_safe) or [] return list(format_stack_details(stacks)) @request_context def count_stacks(self, cnxt, filters=None, tenant_safe=True): """ Return the number of stacks that match the given filters :param ctxt: RPC context. :param filters: a dict of ATTR:VALUE to match against stacks :returns: a integer representing the number of matched stacks """ return db_api.stack_count_all(cnxt, filters=filters, tenant_safe=tenant_safe) def _validate_deferred_auth_context(self, cnxt, stack): if cfg.CONF.deferred_auth_method != 'password': return if not stack.requires_deferred_auth(): return if cnxt.username is None: raise exception.MissingCredentialError(required='X-Auth-User') if cnxt.password is None: raise exception.MissingCredentialError(required='X-Auth-Key') def _validate_new_stack(self, cnxt, stack_name, parsed_template): if db_api.stack_get_by_name(cnxt, stack_name): raise exception.StackExists(stack_name=stack_name) tenant_limit = cfg.CONF.max_stacks_per_tenant if db_api.stack_count_all(cnxt) >= tenant_limit: message = _("You have reached the maximum stacks per tenant, %d." " Please delete some stacks.") % tenant_limit raise exception.RequestLimitExceeded(message=message) num_resources = len(parsed_template[parsed_template.RESOURCES]) if num_resources > cfg.CONF.max_resources_per_stack: message = exception.StackResourceLimitExceeded.msg_fmt raise exception.RequestLimitExceeded(message=message) @request_context def preview_stack(self, cnxt, stack_name, template, params, files, args): """ Simulates a new stack using the provided template. Note that at this stage the template has already been fetched from the heat-api process if using a template-url. :param cnxt: RPC context. :param stack_name: Name of the stack you want to create. :param template: Template of stack you want to create. :param params: Stack Input Params :param files: Files referenced from the template :param args: Request parameters/args passed from API """ logger.info(_('previewing stack %s') % stack_name) tmpl = parser.Template(template, files=files) self._validate_new_stack(cnxt, stack_name, tmpl) common_params = api.extract_args(args) env = environment.Environment(params) stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params) self._validate_deferred_auth_context(cnxt, stack) stack.validate() return api.format_stack_preview(stack) @request_context def create_stack(self, cnxt, stack_name, template, params, files, args): """ The create_stack method creates a new stack using the template provided. Note that at this stage the template has already been fetched from the heat-api process if using a template-url. :param cnxt: RPC context. :param stack_name: Name of the stack you want to create. :param template: Template of stack you want to create. :param params: Stack Input Params :param files: Files referenced from the template :param args: Request parameters/args passed from API """ logger.info(_('template is %s') % template) def _stack_create(stack): # Create/Adopt a stack, and create the periodic task if successful if stack.adopt_stack_data: stack.adopt() else: stack.create() if (stack.action in (stack.CREATE, stack.ADOPT) and stack.status == stack.COMPLETE): # Schedule a periodic watcher task for this stack self.stack_watch.start_watch_task(stack.id, cnxt) else: logger.warning(_("Stack create failed, status %s") % stack.status) tmpl = parser.Template(template, files=files) self._validate_new_stack(cnxt, stack_name, tmpl) # Extract the common query parameters common_params = api.extract_args(args) env = environment.Environment(params) stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params) self._validate_deferred_auth_context(cnxt, stack) stack.validate() stack.store() self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id, _stack_create, stack) return dict(stack.identifier()) @request_context def update_stack(self, cnxt, stack_identity, template, params, files, args): """ The update_stack method updates an existing stack based on the provided template and parameters. Note that at this stage the template has already been fetched from the heat-api process if using a template-url. :param cnxt: RPC context. :param stack_identity: Name of the stack you want to create. :param template: Template of stack you want to create. :param params: Stack Input Params :param files: Files referenced from the template :param args: Request parameters/args passed from API """ logger.info(_('template is %s') % template) # Get the database representation of the existing stack db_stack = self._get_stack(cnxt, stack_identity) current_stack = parser.Stack.load(cnxt, stack=db_stack) if current_stack.action == current_stack.SUSPEND: msg = _('Updating a stack when it is suspended') raise exception.NotSupported(feature=msg) if current_stack.status == current_stack.IN_PROGRESS: msg = _('Updating a stack when another action is in progress') raise exception.NotSupported(feature=msg) # Now parse the template and any parameters for the updated # stack definition. tmpl = parser.Template(template, files=files) if len(tmpl[tmpl.RESOURCES]) > cfg.CONF.max_resources_per_stack: raise exception.RequestLimitExceeded( message=exception.StackResourceLimitExceeded.msg_fmt) stack_name = current_stack.name common_params = api.extract_args(args) common_params.setdefault(rpc_api.PARAM_TIMEOUT, current_stack.timeout_mins) env = environment.Environment(params) updated_stack = parser.Stack(cnxt, stack_name, tmpl, env, **common_params) updated_stack.parameters.set_stack_id(current_stack.identifier()) self._validate_deferred_auth_context(cnxt, updated_stack) updated_stack.validate() self.thread_group_mgr.start_with_lock(cnxt, current_stack, self.engine_id, current_stack.update, updated_stack) return dict(current_stack.identifier()) @request_context def validate_template(self, cnxt, template, params=None): """ The validate_template method uses the stack parser to check the validity of a template. :param cnxt: RPC context. :param template: Template of stack you want to create. :param params: Stack Input Params """ logger.info(_('validate_template')) if template is None: msg = _("No Template provided.") return webob.exc.HTTPBadRequest(explanation=msg) tmpl = parser.Template(template) try: tmpl_resources = tmpl['Resources'] except KeyError as ex: return {'Error': str(ex)} # validate overall template (top-level structure) tmpl.validate() if not tmpl_resources: return {'Error': 'At least one Resources member must be defined.'} env = environment.Environment(params) for res in tmpl_resources.values(): try: if not res.get('Type'): return {'Error': 'Every Resource object must ' 'contain a Type member.'} except AttributeError: type_res = type(res) if isinstance(res, unicode): type_res = "string" return {'Error': 'Resources must contain Resource. ' 'Found a [%s] instead' % type_res} ResourceClass = env.get_class(res['Type']) if ResourceClass == resources.template_resource.TemplateResource: # we can't validate a TemplateResource unless we instantiate # it as we need to download the template and convert the # paramerters into properties_schema. continue props = properties.Properties(ResourceClass.properties_schema, res.get('Properties', {}), context=cnxt) try: ResourceClass.validate_deletion_policy(res) props.validate(with_value=False) except Exception as ex: return {'Error': str(ex)} tmpl_params = tmpl.parameters(None, user_params=env.params) tmpl_params.validate(validate_value=False, context=cnxt) is_real_param = lambda p: p.name not in tmpl_params.PSEUDO_PARAMETERS params = tmpl_params.map(api.format_validate_parameter, is_real_param) param_groups = parameter_groups.ParameterGroups(tmpl) result = { 'Description': tmpl.get('Description', ''), 'Parameters': params, } if param_groups.parameter_groups: result['ParameterGroups'] = param_groups.parameter_groups return result @request_context def authenticated_to_backend(self, cnxt): """ Verify that the credentials in the RPC context are valid for the current cloud backend. """ return clients.Clients(cnxt).authenticated() @request_context def get_template(self, cnxt, stack_identity): """ Get the template. :param cnxt: RPC context. :param stack_identity: Name of the stack you want to see. """ s = self._get_stack(cnxt, stack_identity, show_deleted=True) if s: return s.raw_template.template return None @request_context def delete_stack(self, cnxt, stack_identity): """ The delete_stack method deletes a given stack. :param cnxt: RPC context. :param stack_identity: Name of the stack you want to delete. """ def remote_stop(lock_engine_id): rpc = proxy.RpcProxy(lock_engine_id, "1.0") msg = rpc.make_msg("stop_stack", stack_identity=stack_identity) timeout = cfg.CONF.engine_life_check_timeout try: rpc.call(cnxt, msg, topic=lock_engine_id, timeout=timeout) except rpc_common.Timeout: return False st = self._get_stack(cnxt, stack_identity) logger.info(_('Deleting stack %s') % st.name) stack = parser.Stack.load(cnxt, stack=st) lock = stack_lock.StackLock(cnxt, stack, self.engine_id) acquire_result = lock.try_acquire() # Successfully acquired lock if acquire_result is None: self.thread_group_mgr.stop_timers(stack.id) self.thread_group_mgr.start_with_acquired_lock(stack, lock, stack.delete) return # Current engine has the lock elif acquire_result == self.engine_id: self.thread_group_mgr.stop(stack.id) # Another active engine has the lock elif stack_lock.StackLock.engine_alive(cnxt, acquire_result): stop_result = remote_stop(acquire_result) if stop_result is None: logger.debug(_("Successfully stopped remote task on engine %s") % acquire_result) else: raise exception.StopActionFailed(stack_name=stack.name, engine_id=acquire_result) # If the lock isn't released here, then the call to # start_with_lock below will raise an ActionInProgress # exception. Ideally, we wouldn't be calling another # release() here, since it should be called as soon as the # ThreadGroup is stopped. But apparently there's a race # between release() the next call to lock.acquire(). db_api.stack_lock_release(stack.id, acquire_result) # There may be additional resources that we don't know about # if an update was in-progress when the stack was stopped, so # reload the stack from the database. st = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=st) self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id, stack.delete) return None @request_context def abandon_stack(self, cnxt, stack_identity): """ The abandon_stack method abandons a given stack. :param cnxt: RPC context. :param stack_identity: Name of the stack you want to abandon. """ st = self._get_stack(cnxt, stack_identity) logger.info(_('abandoning stack %s') % st.name) stack = parser.Stack.load(cnxt, stack=st) # Get stack details before deleting it. stack_info = stack.get_abandon_data() # Set deletion policy to 'Retain' for all resources in the stack. stack.set_deletion_policy(resource.RETAIN) self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id, stack.delete) return stack_info def list_resource_types(self, cnxt, support_status=None): """ Get a list of supported resource types. :param cnxt: RPC context. """ return resource.get_types(support_status) def resource_schema(self, cnxt, type_name): """ Return the schema of the specified type. :param cnxt: RPC context. :param type_name: Name of the resource type to obtain the schema of. """ try: resource_class = resource.get_class(type_name) except exception.StackValidationFailed: raise exception.ResourceTypeNotFound(type_name=type_name) def properties_schema(): for name, schema_dict in resource_class.properties_schema.items(): schema = properties.Schema.from_legacy(schema_dict) if schema.implemented: yield name, dict(schema) def attributes_schema(): for schema_item in resource_class.attributes_schema.items(): schema = attributes.Attribute(*schema_item) yield schema.name, {schema.DESCRIPTION: schema.description} return { rpc_api.RES_SCHEMA_RES_TYPE: type_name, rpc_api.RES_SCHEMA_PROPERTIES: dict(properties_schema()), rpc_api.RES_SCHEMA_ATTRIBUTES: dict(attributes_schema()), } def generate_template(self, cnxt, type_name): """ Generate a template based on the specified type. :param cnxt: RPC context. :param type_name: Name of the resource type to generate a template for. """ try: return \ resource.get_class(type_name).resource_to_template(type_name) except exception.StackValidationFailed: raise exception.ResourceTypeNotFound(type_name=type_name) @request_context def list_events(self, cnxt, stack_identity): """ The list_events method lists all events associated with a given stack. :param cnxt: RPC context. :param stack_identity: Name of the stack you want to get events for. """ if stack_identity is not None: st = self._get_stack(cnxt, stack_identity, show_deleted=True) events = db_api.event_get_all_by_stack(cnxt, st.id) else: events = db_api.event_get_all_by_tenant(cnxt) stacks = {} def get_stack(stack_id): if stack_id not in stacks: stacks[stack_id] = parser.Stack.load(cnxt, stack_id) return stacks[stack_id] return [api.format_event(Event.load(cnxt, e.id, e, get_stack(e.stack_id))) for e in events] def _authorize_stack_user(self, cnxt, stack, resource_name): ''' Filter access to describe_stack_resource for stack in-instance users - The user must map to a User resource defined in the requested stack - The user resource must validate OK against any Policy specified ''' # first check whether access is allowd by context user_id if stack.access_allowed(cnxt.user_id, resource_name): return True # fall back to looking for EC2 credentials in the context try: ec2_creds = json.loads(cnxt.aws_creds).get('ec2Credentials') except (TypeError, AttributeError): ec2_creds = None if not ec2_creds: return False access_key = ec2_creds.get('access') return stack.access_allowed(access_key, resource_name) @request_context def describe_stack_resource(self, cnxt, stack_identity, resource_name): s = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=s) if cfg.CONF.heat_stack_user_role in cnxt.roles: if not self._authorize_stack_user(cnxt, stack, resource_name): logger.warning(_("Access denied to resource %s") % resource_name) raise exception.Forbidden() if resource_name not in stack: raise exception.ResourceNotFound(resource_name=resource_name, stack_name=stack.name) resource = stack[resource_name] if resource.id is None: raise exception.ResourceNotAvailable(resource_name=resource_name) return api.format_stack_resource(stack[resource_name]) @request_context def resource_signal(self, cnxt, stack_identity, resource_name, details): s = self._get_stack(cnxt, stack_identity) # This is not "nice" converting to the stored context here, # but this happens because the keystone user associated with the # signal doesn't have permission to read the secret key of # the user associated with the cfn-credentials file stack_context = self.load_user_creds(s.user_creds_id) stack = parser.Stack.load(stack_context, stack=s) if resource_name not in stack: raise exception.ResourceNotFound(resource_name=resource_name, stack_name=stack.name) resource = stack[resource_name] if resource.id is None: raise exception.ResourceNotAvailable(resource_name=resource_name) if callable(stack[resource_name].signal): stack[resource_name].signal(details) @request_context def find_physical_resource(self, cnxt, physical_resource_id): """ Return an identifier for the resource with the specified physical resource ID. :param cnxt: RPC context. :param physical_resource_id: The physical resource ID to look up. """ rs = db_api.resource_get_by_physical_resource_id(cnxt, physical_resource_id) if not rs: raise exception.PhysicalResourceNotFound( resource_id=physical_resource_id) stack = parser.Stack.load(cnxt, stack=rs.stack) resource = stack[rs.name] return dict(resource.identifier()) @request_context def describe_stack_resources(self, cnxt, stack_identity, resource_name): s = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=s) return [api.format_stack_resource(resource) for name, resource in stack.iteritems() if resource_name is None or name == resource_name] @request_context def list_stack_resources(self, cnxt, stack_identity): s = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=s) return [api.format_stack_resource(resource, detail=False) for resource in stack.values()] @request_context def stack_suspend(self, cnxt, stack_identity): ''' Handle request to perform suspend action on a stack ''' def _stack_suspend(stack): logger.debug(_("suspending stack %s") % stack.name) stack.suspend() s = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=s) self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id, _stack_suspend, stack) @request_context def stack_resume(self, cnxt, stack_identity): ''' Handle request to perform a resume action on a stack ''' def _stack_resume(stack): logger.debug(_("resuming stack %s") % stack.name) stack.resume() s = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=s) self.thread_group_mgr.start_with_lock(cnxt, stack, self.engine_id, _stack_resume, stack) @request_context def metadata_update(self, cnxt, stack_identity, resource_name, metadata): """ Update the metadata for the given resource. """ s = self._get_stack(cnxt, stack_identity) stack = parser.Stack.load(cnxt, stack=s) if resource_name not in stack: raise exception.ResourceNotFound(resource_name=resource_name, stack_name=stack.name) resource = stack[resource_name] resource.metadata_update(new_metadata=metadata) # This is not "nice" converting to the stored context here, # but this happens because the keystone user associated with the # WaitCondition doesn't have permission to read the secret key of # the user associated with the cfn-credentials file stack_context = self.load_user_creds(s.user_creds_id) refresh_stack = parser.Stack.load(stack_context, stack=s) # Refresh the metadata for all other resources, since we expect # resource_name to be a WaitCondition resource, and other # resources may refer to WaitCondition Fn::GetAtt Data, which # is updated here. for res in refresh_stack.dependencies: if res.name != resource_name and res.id is not None: res.metadata_update() return resource.metadata @request_context def create_watch_data(self, cnxt, watch_name, stats_data): ''' This could be used by CloudWatch and WaitConditions and treat HA service events like any other CloudWatch. ''' def get_matching_watches(): if watch_name: yield watchrule.WatchRule.load(cnxt, watch_name) else: for wr in db_api.watch_rule_get_all(cnxt): if watchrule.rule_can_use_sample(wr, stats_data): yield watchrule.WatchRule.load(cnxt, watch=wr) rule_run = False for rule in get_matching_watches(): rule.create_watch_data(stats_data) rule_run = True if not rule_run: if watch_name is None: watch_name = 'Unknown' raise exception.WatchRuleNotFound(watch_name=watch_name) return stats_data @request_context def show_watch(self, cnxt, watch_name): """ The show_watch method returns the attributes of one watch/alarm :param cnxt: RPC context. :param watch_name: Name of the watch you want to see, or None to see all """ if watch_name: wrn = [watch_name] else: try: wrn = [w.name for w in db_api.watch_rule_get_all(cnxt)] except Exception as ex: logger.warn(_('show_watch (all) db error %s') % str(ex)) return wrs = [watchrule.WatchRule.load(cnxt, w) for w in wrn] result = [api.format_watch(w) for w in wrs] return result @request_context def show_watch_metric(self, cnxt, metric_namespace=None, metric_name=None): """ The show_watch method returns the datapoints for a metric :param cnxt: RPC context. :param metric_namespace: Name of the namespace you want to see, or None to see all :param metric_name: Name of the metric you want to see, or None to see all """ # DB API and schema does not yet allow us to easily query by # namespace/metric, but we will want this at some point # for now, the API can query all metric data and filter locally if metric_namespace is not None or metric_name is not None: logger.error(_("Filtering by namespace/metric not yet supported")) return try: wds = db_api.watch_data_get_all(cnxt) except Exception as ex: logger.warn(_('show_metric (all) db error %s') % str(ex)) return result = [api.format_watch_data(w) for w in wds] return result @request_context def set_watch_state(self, cnxt, watch_name, state): """ Temporarily set the state of a given watch :param cnxt: RPC context. :param watch_name: Name of the watch :param state: State (must be one defined in WatchRule class """ wr = watchrule.WatchRule.load(cnxt, watch_name) if wr.state == rpc_api.WATCH_STATE_CEILOMETER_CONTROLLED: return actions = wr.set_watch_state(state) for action in actions: self.thread_group_mgr.start(wr.stack_id, action) # Return the watch with the state overriden to indicate success # We do not update the timestamps as we are not modifying the DB result = api.format_watch(wr) result[rpc_api.WATCH_STATE_VALUE] = state return result @request_context def show_software_config(self, cnxt, config_id): sc = db_api.software_config_get(cnxt, config_id) return api.format_software_config(sc) @request_context def create_software_config(self, cnxt, group, name, config, inputs, outputs, options): sc = db_api.software_config_create(cnxt, { 'group': group, 'name': name, 'config': { 'inputs': inputs, 'outputs': outputs, 'options': options, 'config': config }, 'tenant': cnxt.tenant_id}) return api.format_software_config(sc) @request_context def delete_software_config(self, cnxt, config_id): db_api.software_config_delete(cnxt, config_id) @request_context def list_software_deployments(self, cnxt, server_id): all_sd = db_api.software_deployment_get_all(cnxt, server_id) result = [api.format_software_deployment(sd) for sd in all_sd] return result @request_context def metadata_software_deployments(self, cnxt, server_id): if not server_id: raise ValueError(_('server_id must be specified')) all_sd = db_api.software_deployment_get_all(cnxt, server_id) # sort the configs by config name, to give the list of metadata a # deterministic and controllable order. all_sd_s = sorted(all_sd, key=lambda sd: sd.config.name) result = [api.format_software_config(sd.config) for sd in all_sd_s] return result @request_context def show_software_deployment(self, cnxt, deployment_id): sd = db_api.software_deployment_get(cnxt, deployment_id) return api.format_software_deployment(sd) @request_context def create_software_deployment(self, cnxt, server_id, config_id, input_values, action, status, status_reason, stack_user_project_id): sd = db_api.software_deployment_create(cnxt, { 'config_id': config_id, 'server_id': server_id, 'input_values': input_values, 'tenant': cnxt.tenant_id, 'stack_user_project_id': stack_user_project_id, 'action': action, 'status': status, 'status_reason': status_reason}) return api.format_software_deployment(sd) @request_context def update_software_deployment(self, cnxt, deployment_id, config_id, input_values, output_values, action, status, status_reason): update_data = {} if config_id: update_data['config_id'] = config_id if input_values: update_data['input_values'] = input_values if output_values: update_data['output_values'] = output_values if action: update_data['action'] = action if status: update_data['status'] = status if status_reason: update_data['status_reason'] = status_reason sd = db_api.software_deployment_update(cnxt, deployment_id, update_data) return api.format_software_deployment(sd) @request_context def delete_software_deployment(self, cnxt, deployment_id): db_api.software_deployment_delete(cnxt, deployment_id) heat-2014.1.5/heat/engine/stack_lock.py0000664000567000056700000001167112540642614020714 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. import uuid from oslo.config import cfg cfg.CONF.import_opt('engine_life_check_timeout', 'heat.common.config') from heat.common import exception from heat.db import api as db_api from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common.rpc import proxy logger = logging.getLogger(__name__) class StackLock(object): def __init__(self, context, stack, engine_id): self.context = context self.stack = stack self.engine_id = engine_id self.listener = None @staticmethod def engine_alive(context, engine_id): topic = engine_id rpc = proxy.RpcProxy(topic, "1.0") msg = rpc.make_msg("listening") try: return rpc.call(context, msg, topic=topic, timeout=cfg.CONF.engine_life_check_timeout) except rpc_common.Timeout: return False @staticmethod def generate_engine_id(): return str(uuid.uuid4()) def try_acquire(self): """ Try to acquire a stack lock, but don't raise an ActionInProgress exception or try to steal lock. """ return db_api.stack_lock_create(self.stack.id, self.engine_id) def acquire(self, retry=True): """ Acquire a lock on the stack. :param retry: When True, retry if lock was released while stealing. :type retry: boolean """ lock_engine_id = db_api.stack_lock_create(self.stack.id, self.engine_id) if lock_engine_id is None: logger.debug(_("Engine %(engine)s acquired lock on stack " "%(stack)s") % {'engine': self.engine_id, 'stack': self.stack.id}) return if lock_engine_id == self.engine_id or \ self.engine_alive(self.context, lock_engine_id): logger.debug(_("Lock on stack %(stack)s is owned by engine " "%(engine)s") % {'stack': self.stack.id, 'engine': lock_engine_id}) raise exception.ActionInProgress(stack_name=self.stack.name, action=self.stack.action) else: logger.info(_("Stale lock detected on stack %(stack)s. Engine " "%(engine)s will attempt to steal the lock") % {'stack': self.stack.id, 'engine': self.engine_id}) result = db_api.stack_lock_steal(self.stack.id, lock_engine_id, self.engine_id) if result is None: logger.info(_("Engine %(engine)s successfully stole the lock " "on stack %(stack)s") % {'engine': self.engine_id, 'stack': self.stack.id}) return elif result is True: if retry: logger.info(_("The lock on stack %(stack)s was released " "while engine %(engine)s was stealing it. " "Trying again") % {'stack': self.stack.id, 'engine': self.engine_id}) return self.acquire(retry=False) else: new_lock_engine_id = result logger.info(_("Failed to steal lock on stack %(stack)s. " "Engine %(engine)s stole the lock first") % {'stack': self.stack.id, 'engine': new_lock_engine_id}) raise exception.ActionInProgress( stack_name=self.stack.name, action=self.stack.action) def release(self, stack_id): """Release a stack lock.""" # Only the engine that owns the lock will be releasing it. result = db_api.stack_lock_release(stack_id, self.engine_id) if result is True: logger.warning(_("Lock was already released on stack %s!") % stack_id) else: logger.debug(_("Engine %(engine)s released lock on stack " "%(stack)s") % {'engine': self.engine_id, 'stack': stack_id}) heat-2014.1.5/heat/engine/attributes.py0000664000567000056700000000622312540642614020762 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. import collections class Attribute(object): """ An Attribute schema. """ (DESCRIPTION,) = ('description',) def __init__(self, attr_name, description): """ Initialise with a name and description. :param attr_name: the name of the attribute :param description: attribute description """ self.name = attr_name self.description = description def as_output(self, resource_name): """ Return an Output schema entry for a provider template with the given resource name. :param resource_name: the logical name of the provider resource :returns: This attribute as a template 'Output' entry """ return { "Value": '{"Fn::GetAtt": ["%s", "%s"]}' % (resource_name, self.name), "Description": self.description } class Attributes(collections.Mapping): """Models a collection of Resource Attributes.""" def __init__(self, res_name, schema, resolver): self._resource_name = res_name self._resolver = resolver self._attributes = Attributes._make_attributes(schema) @staticmethod def _make_attributes(schema): return dict((n, Attribute(n, d)) for n, d in schema.items()) @staticmethod def as_outputs(resource_name, resource_class): """ :param resource_name: logical name of the resource :param resource_class: resource implementation class :returns: The attributes of the specified resource_class as a template Output map """ schema = resource_class.attributes_schema attribs = Attributes._make_attributes(schema).items() return dict((n, att.as_output(resource_name)) for n, att in attribs) @staticmethod def schema_from_outputs(json_snippet): if json_snippet: return dict((k, v.get("Description")) for k, v in json_snippet.items()) return {} def __getitem__(self, key): if key not in self: raise KeyError(_('%(resource)s: Invalid attribute %(key)s') % dict(resource=self._resource_name, key=key)) return self._resolver(key) def __len__(self): return len(self._attributes) def __contains__(self, key): return key in self._attributes def __iter__(self): return iter(self._attributes) def __repr__(self): return ("Attributes for %s:\n\t" % self._resource_name + '\n\t'.join(self._attributes.values())) heat-2014.1.5/heat/engine/parameter_groups.py0000664000567000056700000000540612540642614022155 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. from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ from heat.common.exception import StackValidationFailed logger = logging.getLogger(__name__) PARAMETER_GROUPS = 'parameter_groups' PARAMETERS = 'parameters' class ParameterGroups(object): ''' The ParameterGroups specified by the stack's template. ''' def __init__(self, tmpl): self.tmpl = tmpl self.parameters = tmpl.parameters(None, {}) logger.debug(self.tmpl) logger.debug(self.parameters) self.parameter_names = [] if self.parameters: self.parameter_names = [param for param in self.parameters] self.parameter_groups = tmpl.get(PARAMETER_GROUPS) def validate(self): ''' Validate that a parameter belongs to only one Parameter Group and that each parameter name references a valid parameter. ''' logger.debug(_('Validating Parameter Groups.')) logger.debug(self.parameter_names) if self.parameter_groups is not None: #Loop through groups and validate parameters grouped_parameters = [] for group in self.parameter_groups: parameters = group.get(PARAMETERS) if parameters is None: raise StackValidationFailed(message=_( 'Parameters must be provided for ' 'each Parameter Group.')) for param in parameters: #Check if param has been added to a previous group if param in grouped_parameters: raise StackValidationFailed(message=_( 'The %s parameter must be assigned to one ' 'Parameter Group only.') % param) else: grouped_parameters.append(param) #Check that grouped parameter references a valid Parameter if param not in self.parameter_names: raise StackValidationFailed(message=_( 'The Parameter name (%s) does not reference ' 'an existing parameter.') % param) heat-2014.1.5/heat/engine/dependencies.py0000664000567000056700000001751512540642614021230 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. import collections import itertools from six.moves import xrange from heat.common import exception from heat.openstack.common.gettextutils import _ class CircularDependencyException(exception.HeatException): msg_fmt = _("Circular Dependency Found: %(cycle)s") class Node(object): '''A node in a dependency graph.''' def __init__(self, requires=None, required_by=None): ''' Initialise the node, optionally with a set of keys this node requires and/or a set of keys that this node is required by. ''' self.require = requires and requires.copy() or set() self.satisfy = required_by and required_by.copy() or set() def copy(self): '''Return a copy of the node.''' return Node(self.require, self.satisfy) def reverse_copy(self): '''Return a copy of the node with the edge directions reversed.''' return Node(self.satisfy, self.require) def required_by(self, source=None): ''' List the keys that require this node, and optionally add a new one. ''' if source is not None: self.satisfy.add(source) return iter(self.satisfy) def requires(self, target): '''Add a key that this node requires.''' self.require.add(target) def __isub__(self, target): '''Remove a key that this node requires.''' self.require.remove(target) return self def __nonzero__(self): '''Return True if this node is not a leaf (it requires other nodes).''' return bool(self.require) def stem(self): '''Return True if this node is a stem (required by nothing).''' return not bool(self.satisfy) def disjoint(self): '''Return True if this node is both a leaf and a stem.''' return (not self) and self.stem() def __len__(self): '''Count the number of keys required by this node.''' return len(self.require) def __iter__(self): '''Iterate over the keys required by this node.''' return iter(self.require) def __str__(self): '''Return a human-readable string representation of the node.''' return '{%s}' % ', '.join(str(n) for n in self) def __repr__(self): '''Return a string representation of the node.''' return repr(self.require) class Graph(collections.defaultdict): '''A mutable mapping of objects to nodes in a dependency graph.''' def __init__(self, *args): super(Graph, self).__init__(Node, *args) def map(self, func): ''' Return a dictionary derived from mapping the supplied function onto each node in the graph. ''' return dict((k, func(n)) for k, n in self.items()) def copy(self): '''Return a copy of the graph.''' return Graph(self.map(lambda n: n.copy())) def reverse_copy(self): '''Return a copy of the graph with the edges reversed.''' return Graph(self.map(lambda n: n.reverse_copy())) def edges(self): '''Return an iterator over all of the edges in the graph.''' def outgoing_edges(rqr, node): if node.disjoint(): yield (rqr, None) else: for rqd in node: yield (rqr, rqd) return itertools.chain.from_iterable(outgoing_edges(*i) for i in self.iteritems()) def __delitem__(self, key): '''Delete the node given by the specified key from the graph.''' node = self[key] for src in node.required_by(): src_node = self[src] if key in src_node: src_node -= key return super(Graph, self).__delitem__(key) def __str__(self): '''Convert the graph to a human-readable string.''' pairs = ('%s: %s' % (str(k), str(v)) for k, v in self.iteritems()) return '{%s}' % ', '.join(pairs) @staticmethod def toposort(graph): ''' Return a topologically sorted iterator over a dependency graph. This is a destructive operation for the graph. ''' for iteration in xrange(len(graph)): for key, node in graph.iteritems(): if not node: yield key del graph[key] break else: # There are nodes remaining, but none without # dependencies: a cycle raise CircularDependencyException(cycle=str(graph)) class Dependencies(object): '''Helper class for calculating a dependency graph.''' def __init__(self, edges=[]): ''' Initialise, optionally with a list of edges, in the form of (requirer, required) tuples. ''' self._graph = Graph() for e in edges: self += e def __iadd__(self, edge): '''Add another edge, in the form of a (requirer, required) tuple.''' requirer, required = edge if required is None: # Just ensure the node is created by accessing the defaultdict self._graph[requirer] else: self._graph[required].required_by(requirer) self._graph[requirer].requires(required) return self def required_by(self, last): ''' List the keys that require the specified node. ''' if last not in self._graph: raise KeyError return self._graph[last].required_by() def __getitem__(self, last): ''' Return a partial dependency graph consisting of the specified node and all those that require it only. ''' if last not in self._graph: raise KeyError def get_edges(key): def requirer_edges(rqr): # Concatenate the dependency on the current node with the # recursive generated list return itertools.chain([(rqr, key)], get_edges(rqr)) # Get the edge list for each node that requires the current node edge_lists = itertools.imap(requirer_edges, self._graph[key].required_by()) # Combine the lists into one long list return itertools.chain.from_iterable(edge_lists) if self._graph[last].stem(): # Nothing requires this, so just add the node itself edges = [(last, None)] else: edges = get_edges(last) return Dependencies(edges) def __str__(self): ''' Return a human-readable string representation of the dependency graph ''' return str(self._graph) def __repr__(self): '''Return a string representation of the object.''' edge_reprs = (repr(e) for e in self._graph.edges()) return 'Dependencies([%s])' % ', '.join(edge_reprs) def graph(self, reverse=False): '''Return a copy of the underlying dependency graph.''' if reverse: return self._graph.reverse_copy() else: return self._graph.copy() def __iter__(self): '''Return a topologically sorted iterator''' return Graph.toposort(self.graph()) def __reversed__(self): '''Return a reverse topologically sorted iterator''' return Graph.toposort(self.graph(reverse=True)) heat-2014.1.5/heat/engine/scheduler.py0000664000567000056700000003655712540642614020567 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. import eventlet import functools import itertools import sys import types from time import time as wallclock from heat.openstack.common import excutils from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) # Whether TaskRunner._sleep actually does an eventlet sleep when called. ENABLE_SLEEP = True def task_description(task): """ Return a human-readable string description of a task suitable for logging the status of the task. """ name = task.__name__ if hasattr(task, '__name__') else None if isinstance(task, types.MethodType): if name is not None and hasattr(task, '__self__'): return '%s from %s' % (name, task.__self__) elif isinstance(task, types.FunctionType): if name is not None: return str(name) return repr(task) class Timeout(BaseException): """ Timeout exception, raised within a task when it has exceeded its allotted (wallclock) running time. This allows the task to perform any necessary cleanup, as well as use a different exception to notify the controlling task if appropriate. If the task suppresses the exception altogether, it will be cancelled but the controlling task will not be notified of the timeout. """ def __init__(self, task_runner, timeout): """ Initialise with the TaskRunner and a timeout period in seconds. """ message = _('%s Timed out') % task_runner super(Timeout, self).__init__(message) # Note that we don't attempt to handle leap seconds or large clock # jumps here. The latter are assumed to be rare and the former # negligible in the context of the timeout. Time zone adjustments, # Daylight Savings and the like *are* handled. PEP 418 adds a proper # monotonic clock, but only in Python 3.3. self._endtime = wallclock() + timeout def expired(self): return wallclock() > self._endtime class ExceptionGroup(Exception): ''' Container for multiple exceptions. This exception is used by DependencyTaskGroup when the flag aggregate_exceptions is set to True and it's re-raised again when all tasks are finished. This way it can be caught later on so that the individual exceptions can be acted upon. ''' def __init__(self, exceptions=None): if exceptions is None: exceptions = list() self.exceptions = list(exceptions) def __str__(self): return str(map(str, self.exceptions)) def __unicode__(self): return unicode(map(str, self.exceptions)) class TaskRunner(object): """ Wrapper for a resumable task (co-routine). """ def __init__(self, task, *args, **kwargs): """ Initialise with a task function, and arguments to be passed to it when it is started. The task function may be a co-routine that yields control flow between steps. """ assert callable(task), "Task is not callable" self._task = task self._args = args self._kwargs = kwargs self._runner = None self._done = False self._timeout = None self.name = task_description(task) def __str__(self): """Return a human-readable string representation of the task.""" return 'Task %s' % self.name def _sleep(self, wait_time): """Sleep for the specified number of seconds.""" if ENABLE_SLEEP and wait_time is not None: logger.debug(_('%s sleeping') % str(self)) eventlet.sleep(wait_time) def __call__(self, wait_time=1, timeout=None): """ Start and run the task to completion. The task will sleep for `wait_time` seconds between steps. To avoid sleeping, pass `None` for `wait_time`. """ self.start(timeout=timeout) self.run_to_completion(wait_time=wait_time) def start(self, timeout=None): """ Initialise the task and run its first step. If a timeout is specified, any attempt to step the task after that number of seconds has elapsed will result in a Timeout being raised inside the task. """ assert self._runner is None, "Task already started" logger.debug(_('%s starting') % str(self)) if timeout is not None: self._timeout = Timeout(self, timeout) result = self._task(*self._args, **self._kwargs) if isinstance(result, types.GeneratorType): self._runner = result self.step() else: self._runner = False self._done = True logger.debug(_('%s done (not resumable)') % str(self)) def step(self): """ Run another step of the task, and return True if the task is complete; False otherwise. """ if not self.done(): assert self._runner is not None, "Task not started" if self._timeout is not None and self._timeout.expired(): logger.info(_('%s timed out') % str(self)) try: self._runner.throw(self._timeout) except StopIteration: self._done = True else: # Clean up in case task swallows exception without exiting self.cancel() else: logger.debug(_('%s running') % str(self)) try: next(self._runner) except StopIteration: self._done = True logger.debug(_('%s complete') % str(self)) return self._done def run_to_completion(self, wait_time=1): """ Run the task to completion. The task will sleep for `wait_time` seconds between steps. To avoid sleeping, pass `None` for `wait_time`. """ while not self.step(): self._sleep(wait_time) def cancel(self): """Cancel the task and mark it as done.""" if not self.done(): logger.debug(_('%s cancelled') % str(self)) try: if self.started(): self._runner.close() finally: self._done = True def started(self): """Return True if the task has been started.""" return self._runner is not None def done(self): """Return True if the task is complete.""" return self._done def __nonzero__(self): """Return True if there are steps remaining.""" return not self.done() def wrappertask(task): """ Decorator for a task that needs to drive a subtask. This is essentially a replacement for the Python 3-only "yield from" keyword (PEP 380), using the "yield" keyword that is supported in Python 2. For example:: @wrappertask def parent_task(self): self.setup() yield self.child_task() self.cleanup() """ @functools.wraps(task) def wrapper(*args, **kwargs): parent = task(*args, **kwargs) subtask = next(parent) while True: try: if subtask is not None: subtask_running = True try: step = next(subtask) except StopIteration: subtask_running = False while subtask_running: try: yield step except GeneratorExit as ex: subtask.close() raise ex except: try: step = subtask.throw(*sys.exc_info()) except StopIteration: subtask_running = False else: try: step = next(subtask) except StopIteration: subtask_running = False else: yield except GeneratorExit as ex: parent.close() raise ex except: subtask = parent.throw(*sys.exc_info()) else: subtask = next(parent) return wrapper class DependencyTaskGroup(object): """ A task which manages a group of subtasks that have ordering dependencies. """ def __init__(self, dependencies, task=lambda o: o(), reverse=False, name=None, aggregate_exceptions=False): """ Initialise with the task dependencies and (optionally) a task to run on each. If no task is supplied, it is assumed that the tasks are stored directly in the dependency tree. If a task is supplied, the object stored in the dependency tree is passed as an argument. If aggregate_exceptions is set to True, then all the tasks will be run and any raised exceptions will be stored to be re-raised after all tasks are done. """ self._runners = dict((o, TaskRunner(task, o)) for o in dependencies) self._graph = dependencies.graph(reverse=reverse) self.aggregate_exceptions = aggregate_exceptions if name is None: name = '(%s) %s' % (getattr(task, '__name__', task_description(task)), str(dependencies)) self.name = name def __repr__(self): """Return a string representation of the task.""" return '%s(%s)' % (type(self).__name__, self.name) def __call__(self): """Return a co-routine which runs the task group.""" raised_exceptions = [] try: while any(self._runners.itervalues()): try: for k, r in self._ready(): r.start() yield for k, r in self._running(): if r.step(): del self._graph[k] except Exception as e: self._cancel_recursively(k, r) if not self.aggregate_exceptions: raise raised_exceptions.append(e) except: with excutils.save_and_reraise_exception(): for r in self._runners.itervalues(): r.cancel() if raised_exceptions: raise ExceptionGroup(raised_exceptions) def _cancel_recursively(self, key, runner): runner.cancel() node = self._graph[key] for dependent_node in node.required_by(): node_runner = self._runners[dependent_node] self._cancel_recursively(dependent_node, node_runner) del self._graph[key] def _ready(self): """ Iterate over all subtasks that are ready to start - i.e. all their dependencies have been satisfied but they have not yet been started. """ for k, n in self._graph.iteritems(): if not n: runner = self._runners[k] if not runner.started(): yield k, runner def _running(self): """ Iterate over all subtasks that are currently running - i.e. they have been started but have not yet completed. """ running = lambda (k, r): k in self._graph and r.started() return itertools.ifilter(running, self._runners.iteritems()) class PollingTaskGroup(object): """ A task which manages a group of subtasks. When the task is started, all of its subtasks are also started. The task completes when all subtasks are complete. Once started, the subtasks are assumed to be only polling for completion of an asynchronous operation, so no attempt is made to give them equal scheduling slots. """ def __init__(self, tasks, name=None): """Initialise with a list of tasks.""" self._tasks = list(tasks) if name is None: name = ', '.join(task_description(t) for t in self._tasks) self.name = name @staticmethod def _args(arg_lists): """Return a list containing the positional args for each subtask.""" return zip(*arg_lists) @staticmethod def _kwargs(kwarg_lists): """Return a list containing the keyword args for each subtask.""" keygroups = (itertools.izip(itertools.repeat(name), arglist) for name, arglist in kwarg_lists.iteritems()) return [dict(kwargs) for kwargs in itertools.izip(*keygroups)] @classmethod def from_task_with_args(cls, task, *arg_lists, **kwarg_lists): """ Return a new PollingTaskGroup where each subtask is identical except for the arguments passed to it. Each argument to use should be passed as a list (or iterable) of values such that one is passed in the corresponding position for each subtask. The number of subtasks spawned depends on the length of the argument lists. For example: PollingTaskGroup.from_task_with_args(my_task, [1, 2, 3], alpha=['a', 'b', 'c']) will start three TaskRunners that will run: my_task(1, alpha='a') my_task(2, alpha='b') my_task(3, alpha='c') respectively. If multiple arguments are supplied, each list should be of the same length. In the case of any discrepancy, the length of the shortest argument list will be used, and any extra arguments discarded. """ args_list = cls._args(arg_lists) kwargs_list = cls._kwargs(kwarg_lists) if kwarg_lists and not arg_lists: args_list = [[]] * len(kwargs_list) elif arg_lists and not kwarg_lists: kwargs_list = [{}] * len(args_list) task_args = itertools.izip(args_list, kwargs_list) tasks = (functools.partial(task, *a, **kwa) for a, kwa in task_args) return cls(tasks, name=task_description(task)) def __repr__(self): """Return a string representation of the task group.""" return '%s(%s)' % (type(self).__name__, self.name) def __call__(self): """Return a co-routine which runs the task group.""" runners = [TaskRunner(t) for t in self._tasks] try: for r in runners: r.start() while runners: yield runners = list(itertools.dropwhile(lambda r: r.step(), runners)) except: with excutils.save_and_reraise_exception(): for r in runners: r.cancel() heat-2014.1.5/heat/engine/hot/0000775000567000056700000000000012540643116017007 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/hot/parameters.py0000664000567000056700000001251112540642614021526 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # # 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. from heat.engine import constraints as constr from heat.engine import parameters from heat.openstack.common import log as logging logger = logging.getLogger(__name__) PARAM_CONSTRAINTS = ( CONSTRAINTS, DESCRIPTION, LENGTH, RANGE, MIN, MAX, ALLOWED_VALUES, ALLOWED_PATTERN, CUSTOM_CONSTRAINT, ) = ( 'constraints', 'description', 'length', 'range', 'min', 'max', 'allowed_values', 'allowed_pattern', 'custom_constraint', ) class HOTParamSchema(parameters.Schema): """HOT parameter schema.""" KEYS = ( TYPE, DESCRIPTION, DEFAULT, SCHEMA, CONSTRAINTS, HIDDEN, LABEL ) = ( 'type', 'description', 'default', 'schema', 'constraints', 'hidden', 'label' ) # For Parameters the type name for Schema.LIST is comma_delimited_list # and the type name for Schema.MAP is json TYPES = ( STRING, NUMBER, LIST, MAP, ) = ( 'string', 'number', 'comma_delimited_list', 'json', ) PARAMETER_KEYS = KEYS @classmethod def from_dict(cls, schema_dict): """ Return a Parameter Schema object from a legacy schema dictionary. """ cls._validate_dict(schema_dict) def constraints(): constraints = schema_dict.get(CONSTRAINTS) if constraints is None: return if not isinstance(constraints, list): raise constr.InvalidSchemaError( _("Invalid parameter constraints, expected a list")) valid_keys = (DESCRIPTION, LENGTH, RANGE, ALLOWED_VALUES, ALLOWED_PATTERN, CUSTOM_CONSTRAINT) for constraint in constraints: cls._check_dict(constraint, valid_keys, 'parameter constraints') desc = constraint.get(DESCRIPTION) if RANGE in constraint: cdef = constraint.get(RANGE) cls._check_dict(cdef, (MIN, MAX), 'range constraint') yield constr.Range(parameters.Schema.get_num(MIN, cdef), parameters.Schema.get_num(MAX, cdef), desc) elif LENGTH in constraint: cdef = constraint.get(LENGTH) cls._check_dict(cdef, (MIN, MAX), 'length constraint') yield constr.Length(parameters.Schema.get_num(MIN, cdef), parameters.Schema.get_num(MAX, cdef), desc) elif ALLOWED_VALUES in constraint: cdef = constraint.get(ALLOWED_VALUES) yield constr.AllowedValues(cdef, desc) elif ALLOWED_PATTERN in constraint: cdef = constraint.get(ALLOWED_PATTERN) yield constr.AllowedPattern(cdef, desc) elif CUSTOM_CONSTRAINT in constraint: cdef = constraint.get(CUSTOM_CONSTRAINT) yield constr.CustomConstraint(cdef, desc) else: raise constr.InvalidSchemaError( _("No constraint expressed")) # make update_allowed true by default on TemplateResources # as the template should deal with this. return cls(schema_dict[cls.TYPE], description=schema_dict.get(HOTParamSchema.DESCRIPTION), default=schema_dict.get(HOTParamSchema.DEFAULT), constraints=list(constraints()), hidden=schema_dict.get(HOTParamSchema.HIDDEN, False), label=schema_dict.get(HOTParamSchema.LABEL)) class HOTParameters(parameters.Parameters): PSEUDO_PARAMETERS = ( PARAM_STACK_ID, PARAM_STACK_NAME, PARAM_REGION ) = ( 'OS::stack_id', 'OS::stack_name', 'OS::region' ) def set_stack_id(self, stack_identifier): ''' Set the StackId pseudo parameter value ''' if stack_identifier is not None: self.params[self.PARAM_STACK_ID].schema.set_default( stack_identifier.stack_id) return True return False def _pseudo_parameters(self, stack_identifier): stack_id = getattr(stack_identifier, 'stack_id', '') stack_name = getattr(stack_identifier, 'stack_name', '') yield parameters.Parameter( self.PARAM_STACK_ID, parameters.Schema(parameters.Schema.STRING, _('Stack ID'), default=str(stack_id))) if stack_name: yield parameters.Parameter( self.PARAM_STACK_NAME, parameters.Schema(parameters.Schema.STRING, _('Stack Name'), default=stack_name)) heat-2014.1.5/heat/engine/hot/template.py0000664000567000056700000001302012540642614021172 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. from heat.engine import template from heat.engine.cfn import template as cfn_template from heat.engine.hot import parameters from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class HOTemplate(template.Template): """ A Heat Orchestration Template format stack template. """ SECTIONS = (VERSION, DESCRIPTION, PARAMETER_GROUPS, PARAMETERS, RESOURCES, OUTPUTS, MAPPINGS) = \ ('heat_template_version', 'description', 'parameter_groups', 'parameters', 'resources', 'outputs', '__undefined__') SECTIONS_NO_DIRECT_ACCESS = set([PARAMETERS, VERSION]) VERSIONS = ('2013-05-23',) _CFN_TO_HOT_SECTIONS = {cfn_template.CfnTemplate.VERSION: VERSION, cfn_template.CfnTemplate.DESCRIPTION: DESCRIPTION, cfn_template.CfnTemplate.PARAMETERS: PARAMETERS, cfn_template.CfnTemplate.MAPPINGS: MAPPINGS, cfn_template.CfnTemplate.RESOURCES: RESOURCES, cfn_template.CfnTemplate.OUTPUTS: OUTPUTS} def __getitem__(self, section): """"Get the relevant section in the template.""" #first translate from CFN into HOT terminology if necessary if section not in self.SECTIONS: section = HOTemplate._translate(section, self._CFN_TO_HOT_SECTIONS, _('"%s" is not a valid template ' 'section')) if section not in self.SECTIONS: raise KeyError(_('"%s" is not a valid template section') % section) if section in self.SECTIONS_NO_DIRECT_ACCESS: raise KeyError( _('Section %s can not be accessed directly.') % section) if section == self.MAPPINGS: return {} if section == self.DESCRIPTION: default = 'No description' else: default = {} the_section = self.t.get(section, default) # In some cases (e.g. parameters), also translate each entry of # a section into CFN format (case, naming, etc) so the rest of the # engine can cope with it. # This is a shortcut for now and might be changed in the future. if section == self.RESOURCES: return self._translate_resources(the_section) if section == self.OUTPUTS: return self._translate_outputs(the_section) return the_section @staticmethod def _translate(value, mapping, err_msg=None): try: return mapping[value] except KeyError as ke: if err_msg: raise KeyError(err_msg % value) else: raise ke def _translate_resources(self, resources): """Get the resources of the template translated into CFN format.""" HOT_TO_CFN_ATTRS = {'type': 'Type', 'properties': 'Properties', 'metadata': 'Metadata', 'depends_on': 'DependsOn', 'deletion_policy': 'DeletionPolicy', 'update_policy': 'UpdatePolicy'} cfn_resources = {} for resource_name, attrs in resources.iteritems(): cfn_resource = {} for attr, attr_value in attrs.iteritems(): cfn_attr = self._translate(attr, HOT_TO_CFN_ATTRS, _('"%s" is not a valid keyword ' 'inside a resource definition')) cfn_resource[cfn_attr] = attr_value cfn_resources[resource_name] = cfn_resource return cfn_resources def _translate_outputs(self, outputs): """Get the outputs of the template translated into CFN format.""" HOT_TO_CFN_ATTRS = {'description': 'Description', 'value': 'Value'} cfn_outputs = {} for output_name, attrs in outputs.iteritems(): cfn_output = {} for attr, attr_value in attrs.iteritems(): cfn_attr = self._translate(attr, HOT_TO_CFN_ATTRS, _('"%s" is not a valid keyword ' 'inside an output definition')) cfn_output[cfn_attr] = attr_value cfn_outputs[output_name] = cfn_output return cfn_outputs def param_schemata(self): params = self.t.get(self.PARAMETERS, {}).iteritems() return dict((name, parameters.HOTParamSchema.from_dict(schema)) for name, schema in params) def parameters(self, stack_identifier, user_params): return parameters.HOTParameters(stack_identifier, self, user_params=user_params) def template_mapping(): return { ('heat_template_version', '2013-05-23'): HOTemplate, } heat-2014.1.5/heat/engine/hot/__init__.py0000664000567000056700000000000012540642611021105 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/engine/hot/functions.py0000664000567000056700000001652612540642614021405 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. import collections from heat.common import exception from heat.engine.cfn import functions as cfn_funcs from heat.engine import function class GetParam(function.Function): ''' A function for resolving parameter references. Takes the form:: get_param: or:: get_param: - - - ... ''' def __init__(self, stack, fn_name, args): super(GetParam, self).__init__(stack, fn_name, args) self.parameters = self.stack.parameters def result(self): args = function.resolve(self.args) if not args: raise ValueError(_('Function "%s" must have arguments') % self.fn_name) if isinstance(args, basestring): param_name = args path_components = [] elif isinstance(args, collections.Sequence): param_name = args[0] path_components = args[1:] else: raise TypeError(_('Argument to "%s" must be string or list') % self.fn_name) if not isinstance(param_name, basestring): raise TypeError(_('Parameter name in "%s" must be string') % self.fn_name) try: parameter = self.parameters[param_name] except KeyError: raise exception.UserParameterMissing(key=param_name) def get_path_component(collection, key): if not isinstance(collection, (collections.Mapping, collections.Sequence)): raise TypeError(_('"%s" can\'t traverse path') % self.fn_name) if not isinstance(key, (basestring, int)): raise TypeError(_('Path components in "%s" ' 'must be strings') % self.fn_name) return collection[key] try: return reduce(get_path_component, path_components, parameter) except (KeyError, IndexError, TypeError): return '' class GetAtt(cfn_funcs.GetAtt): ''' A function for resolving resource attributes. Takes the form:: get_attr: - - - - ... ''' def _parse_args(self): if (not isinstance(self.args, collections.Sequence) or isinstance(self.args, basestring)): raise TypeError(_('Argument to "%s" must be a list') % self.fn_name) if len(self.args) < 2: raise ValueError(_('Arguments to "%s" must be of the form ' '[resource_name, attribute, (path), ...]') % self.fn_name) self._path_components = self.args[2:] return tuple(self.args[:2]) def result(self): attribute = super(GetAtt, self).result() if attribute is None: return None path_components = function.resolve(self._path_components) def get_path_component(collection, key): if not isinstance(collection, (collections.Mapping, collections.Sequence)): raise TypeError(_('"%s" can\'t traverse path') % self.fn_name) if not isinstance(key, (basestring, int)): raise TypeError(_('Path components in "%s" ' 'must be strings') % self.fn_name) return collection[key] try: return reduce(get_path_component, path_components, attribute) except (KeyError, IndexError, TypeError): return None class Replace(cfn_funcs.Replace): ''' A function for performing string substitutions. Takes the form:: str_replace: template: params: : : ... And resolves to:: " " This is implemented using Python's str.replace on each key. The order in which replacements are performed is undefined. ''' def _parse_args(self): if not isinstance(self.args, collections.Mapping): raise TypeError(_('Arguments to "%s" must be a map') % self.fn_name) try: mapping = self.args['params'] string = self.args['template'] except (KeyError, TypeError): example = ('''str_replace: template: This is var1 template var2 params: var1: a var2: string''') raise KeyError(_('"str_replace" syntax should be %s') % example) else: return mapping, string class GetFile(function.Function): """ A function for including a file inline. Takes the form:: get_file: And resolves to the content stored in the files dictionary under the given key. """ def result(self): args = function.resolve(self.args) if not (isinstance(args, basestring)): raise TypeError(_('Argument to "%s" must be a string') % self.fn_name) f = self.stack.t.files.get(args) if f is None: fmt_data = {'fn_name': self.fn_name, 'file_key': args} raise ValueError(_('No content found in the "files" section for ' '%(fn_name)s path: %(file_key)s') % fmt_data) return f class ResourceFacade(cfn_funcs.ResourceFacade): ''' A function for obtaining data from the facade resource from within the corresponding provider template. Takes the form:: resource_facade: where the valid attribute types are "metadata", "deletion_policy" and "update_policy". ''' _RESOURCE_ATTRIBUTES = ( METADATA, DELETION_POLICY, UPDATE_POLICY, ) = ( 'metadata', 'deletion_policy', 'update_policy' ) def function_mapping(version_key, version): if version_key != 'heat_template_version': return {} if version == '2013-05-23': return { 'Fn::GetAZs': cfn_funcs.GetAZs, 'get_param': GetParam, 'get_resource': cfn_funcs.ResourceRef, 'Ref': cfn_funcs.Ref, 'get_attr': GetAtt, 'Fn::Select': cfn_funcs.Select, 'Fn::Join': cfn_funcs.Join, 'Fn::Split': cfn_funcs.Split, 'str_replace': Replace, 'Fn::Replace': cfn_funcs.Replace, 'Fn::Base64': cfn_funcs.Base64, 'Fn::MemberListToMap': cfn_funcs.MemberListToMap, 'resource_facade': ResourceFacade, 'Fn::ResourceFacade': cfn_funcs.ResourceFacade, 'get_file': GetFile, } return {} heat-2014.1.5/heat/engine/watchrule.py0000664000567000056700000003244212540642614020574 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. import datetime from heat.common import exception from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ from heat.openstack.common import timeutils from heat.engine import timestamp from heat.db import api as db_api from heat.engine import parser from heat.rpc import api as rpc_api logger = logging.getLogger(__name__) class WatchRule(object): WATCH_STATES = ( ALARM, NORMAL, NODATA, SUSPENDED, CEILOMETER_CONTROLLED, ) = ( rpc_api.WATCH_STATE_ALARM, rpc_api.WATCH_STATE_OK, rpc_api.WATCH_STATE_NODATA, rpc_api.WATCH_STATE_SUSPENDED, rpc_api.WATCH_STATE_CEILOMETER_CONTROLLED, ) ACTION_MAP = {ALARM: 'AlarmActions', NORMAL: 'OKActions', NODATA: 'InsufficientDataActions'} created_at = timestamp.Timestamp(db_api.watch_rule_get, 'created_at') updated_at = timestamp.Timestamp(db_api.watch_rule_get, 'updated_at') def __init__(self, context, watch_name, rule, stack_id=None, state=NODATA, wid=None, watch_data=[], last_evaluated=timeutils.utcnow()): self.context = context self.now = timeutils.utcnow() self.name = watch_name self.state = state self.rule = rule self.stack_id = stack_id period = 0 if 'Period' in rule: period = int(rule['Period']) elif 'period' in rule: period = int(rule['period']) self.timeperiod = datetime.timedelta(seconds=period) self.id = wid self.watch_data = watch_data self.last_evaluated = last_evaluated @classmethod def load(cls, context, watch_name=None, watch=None): ''' Load the watchrule object, either by name or via an existing DB object ''' if watch is None: try: watch = db_api.watch_rule_get_by_name(context, watch_name) except Exception as ex: logger.warn(_('WatchRule.load (%(watch_name)s) db error ' '%(ex)s') % { 'watch_name': watch_name, 'ex': str(ex)}) if watch is None: raise exception.WatchRuleNotFound(watch_name=watch_name) else: return cls(context=context, watch_name=watch.name, rule=watch.rule, stack_id=watch.stack_id, state=watch.state, wid=watch.id, watch_data=watch.watch_data, last_evaluated=watch.last_evaluated) def store(self): ''' Store the watchrule in the database and return its ID If self.id is set, we update the existing rule ''' wr_values = { 'name': self.name, 'rule': self.rule, 'state': self.state, 'stack_id': self.stack_id } if not self.id: wr = db_api.watch_rule_create(self.context, wr_values) self.id = wr.id else: db_api.watch_rule_update(self.context, self.id, wr_values) def destroy(self): ''' Delete the watchrule from the database. ''' if self.id: db_api.watch_rule_delete(self.context, self.id) def do_data_cmp(self, data, threshold): op = self.rule['ComparisonOperator'] if op == 'GreaterThanThreshold': return data > threshold elif op == 'GreaterThanOrEqualToThreshold': return data >= threshold elif op == 'LessThanThreshold': return data < threshold elif op == 'LessThanOrEqualToThreshold': return data <= threshold else: return False def do_Maximum(self): data = 0 have_data = False for d in self.watch_data: if d.created_at < self.now - self.timeperiod: continue if not have_data: data = float(d.data[self.rule['MetricName']]['Value']) have_data = True if float(d.data[self.rule['MetricName']]['Value']) > data: data = float(d.data[self.rule['MetricName']]['Value']) if not have_data: return self.NODATA if self.do_data_cmp(data, float(self.rule['Threshold'])): return self.ALARM else: return self.NORMAL def do_Minimum(self): data = 0 have_data = False for d in self.watch_data: if d.created_at < self.now - self.timeperiod: continue if not have_data: data = float(d.data[self.rule['MetricName']]['Value']) have_data = True elif float(d.data[self.rule['MetricName']]['Value']) < data: data = float(d.data[self.rule['MetricName']]['Value']) if not have_data: return self.NODATA if self.do_data_cmp(data, float(self.rule['Threshold'])): return self.ALARM else: return self.NORMAL def do_SampleCount(self): ''' count all samples within the specified period ''' data = 0 for d in self.watch_data: if d.created_at < self.now - self.timeperiod: continue data = data + 1 if self.do_data_cmp(data, float(self.rule['Threshold'])): return self.ALARM else: return self.NORMAL def do_Average(self): data = 0 samples = 0 for d in self.watch_data: if d.created_at < self.now - self.timeperiod: continue samples = samples + 1 data = data + float(d.data[self.rule['MetricName']]['Value']) if samples == 0: return self.NODATA data = data / samples if self.do_data_cmp(data, float(self.rule['Threshold'])): return self.ALARM else: return self.NORMAL def do_Sum(self): data = 0 for d in self.watch_data: if d.created_at < self.now - self.timeperiod: logger.debug(_('ignoring %s') % str(d.data)) continue data = data + float(d.data[self.rule['MetricName']]['Value']) if self.do_data_cmp(data, float(self.rule['Threshold'])): return self.ALARM else: return self.NORMAL def get_alarm_state(self): fn = getattr(self, 'do_%s' % self.rule['Statistic']) return fn() def evaluate(self): if self.state == self.SUSPENDED: return [] # has enough time progressed to run the rule self.now = timeutils.utcnow() if self.now < (self.last_evaluated + self.timeperiod): return [] return self.run_rule() def get_details(self): return {'alarm': self.name, 'state': self.state} def run_rule(self): new_state = self.get_alarm_state() actions = self.rule_actions(new_state) self.state = new_state self.last_evaluated = self.now self.store() return actions def rule_actions(self, new_state): logger.info(_('WATCH: stack:%(stack)s, watch_name:%(watch_name)s, ' 'new_state:%(new_state)s'), {'stack': self.stack_id, 'watch_name': self.name, 'new_state': new_state}) actions = [] if self.ACTION_MAP[new_state] not in self.rule: logger.info(_('no action for new state %s'), new_state) else: s = db_api.stack_get(self.context, self.stack_id) stack = parser.Stack.load(self.context, stack=s) if (stack.action != stack.DELETE and stack.status == stack.COMPLETE): for refid in self.rule[self.ACTION_MAP[new_state]]: actions.append(stack.resource_by_refid(refid).signal) else: logger.warning(_("Could not process watch state %s for stack") % new_state) return actions def _to_ceilometer(self, data): from heat.engine import clients clients = clients.Clients(self.context) sample = {} sample['meter_type'] = 'gauge' for k, d in iter(data.items()): if k == 'Namespace': continue sample['meter_name'] = k sample['sample_volume'] = d['Value'] sample['meter_unit'] = d['Unit'] dims = d.get('Dimensions', {}) if isinstance(dims, list): dims = dims[0] sample['resource_metadata'] = dims sample['resource_id'] = dims.get('InstanceId') logger.debug(_('new sample:%(k)s data:%(sample)s') % { 'k': k, 'sample': sample}) clients.ceilometer().samples.create(**sample) def create_watch_data(self, data): if self.state == self.CEILOMETER_CONTROLLED: # this is a short term measure for those that have cfn-push-stats # within their templates, but want to use Ceilometer alarms. self._to_ceilometer(data) return if self.state == self.SUSPENDED: logger.debug(_('Ignoring metric data for %s, SUSPENDED state') % self.name) return [] if self.rule['MetricName'] not in data: # Our simplified cloudwatch implementation only expects a single # Metric associated with each alarm, but some cfn-push-stats # options, e.g --haproxy try to push multiple metrics when we # actually only care about one (the one we're alarming on) # so just ignore any data which doesn't contain MetricName logger.debug(_('Ignoring metric data (only accept %(metric)s) ' ': %(data)s') % { 'metric': self.rule['MetricName'], 'data': data}) return watch_data = { 'data': data, 'watch_rule_id': self.id } wd = db_api.watch_data_create(None, watch_data) logger.debug(_('new watch:%(name)s data:%(data)s') % {'name': self.name, 'data': str(wd.data)}) def state_set(self, state): ''' Persistently store the watch state ''' if state not in self.WATCH_STATES: raise ValueError(_("Invalid watch state %s") % state) self.state = state self.store() def set_watch_state(self, state): ''' Temporarily set the watch state, returns list of functions to be scheduled in the stack ThreadGroup for the specified state ''' if state not in self.WATCH_STATES: raise ValueError(_('Unknown watch state %s') % state) actions = [] if state != self.state: actions = self.rule_actions(state) if actions: logger.debug(_("Overriding state %(self_state)s for watch " "%(name)s with %(state)s") % { 'self_state': self.state, 'name': self.name, 'state': state}) else: logger.warning(_("Unable to override state %(state)s for " "watch %(name)s") % { 'state': self.state, 'name': self.name}) return actions def rule_can_use_sample(wr, stats_data): def match_dimesions(rule, data): for k, v in iter(rule.items()): if k not in data: return False elif v != data[k]: return False return True if wr.state == WatchRule.SUSPENDED: return False if wr.state == WatchRule.CEILOMETER_CONTROLLED: metric = wr.rule['meter_name'] rule_dims = {} for k, v in iter(wr.rule.get('matching_metadata', {}).items()): name = k.split('.')[-1] rule_dims[name] = v else: metric = wr.rule['MetricName'] rule_dims = dict((d['Name'], d['Value']) for d in wr.rule.get('Dimensions', [])) if metric not in stats_data: return False for k, v in iter(stats_data.items()): if k == 'Namespace': continue if k == metric: data_dims = v.get('Dimensions', {}) if isinstance(data_dims, list): data_dims = data_dims[0] if match_dimesions(rule_dims, data_dims): return True return False heat-2014.1.5/heat/engine/event.py0000664000567000056700000000732212540642614017716 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. from heat.db import api as db_api from heat.common import exception from heat.common import identifier from heat.openstack.common import log as logging from heat.openstack.common.gettextutils import _ logger = logging.getLogger(__name__) class Event(object): '''Class representing a Resource state change.''' def __init__(self, context, stack, action, status, reason, physical_resource_id, resource_properties, resource_name, resource_type, uuid=None, timestamp=None, id=None): ''' Initialise from a context, stack, and event information. The timestamp and database ID may also be initialised if the event is already in the database. ''' self.context = context self.stack = stack self.action = action self.status = status self.reason = reason self.physical_resource_id = physical_resource_id self.resource_name = resource_name self.resource_type = resource_type try: self.resource_properties = dict(resource_properties) except ValueError as ex: self.resource_properties = {'Error': str(ex)} self.uuid = uuid self.timestamp = timestamp self.id = id @classmethod def load(cls, context, event_id, event=None, stack=None): '''Retrieve an Event from the database.''' from heat.engine import parser ev = event if event is not None else\ db_api.event_get(context, event_id) if ev is None: message = _('No event exists with id "%s"') % str(event_id) raise exception.NotFound(message) st = stack if stack is not None else\ parser.Stack.load(context, ev.stack_id) return cls(context, st, ev.resource_action, ev.resource_status, ev.resource_status_reason, ev.physical_resource_id, ev.resource_properties, ev.resource_name, ev.resource_type, ev.uuid, ev.created_at, ev.id) def store(self): '''Store the Event in the database.''' ev = { 'resource_name': self.resource_name, 'physical_resource_id': self.physical_resource_id, 'stack_id': self.stack.id, 'resource_action': self.action, 'resource_status': self.status, 'resource_status_reason': self.reason, 'resource_type': self.resource_type, 'resource_properties': self.resource_properties, } if self.uuid is not None: ev['uuid'] = self.uuid if self.timestamp is not None: ev['created_at'] = self.timestamp if self.id is not None: logger.warning(_('Duplicating event')) new_ev = db_api.event_create(self.context, ev) self.id = new_ev.id return self.id def identifier(self): '''Return a unique identifier for the event.''' if self.uuid is None: return None res_id = identifier.ResourceIdentifier( resource_name=self.resource_name, **self.stack.identifier()) return identifier.EventIdentifier(event_id=str(self.uuid), **res_id) heat-2014.1.5/heat/__init__.py0000664000567000056700000000130012540642614017055 0ustar jenkinsjenkins00000000000000 # Copyright 2013 IBM Corp. # 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. from heat.openstack.common import gettextutils gettextutils.install('heat') heat-2014.1.5/heat/doc/0000775000567000056700000000000012540643116015515 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/doc/__init__.py0000664000567000056700000000000012540642614017616 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/0000775000567000056700000000000012540643116016112 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/test_resource_group.py0000664000567000056700000002002712540642614022571 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. import copy import mock from heat.common import exception from heat.engine import resource from heat.engine.resources import resource_group from heat.engine import scheduler from heat.tests import common from heat.tests import generic_resource from heat.tests import utils template = { "heat_template_version": "2013-05-23", "resources": { "group1": { "type": "OS::Heat::ResourceGroup", "properties": { "count": 2, "resource_def": { "type": "dummy.resource", "properties": { "Foo": "Bar" } } } } } } template2 = { "heat_template_version": "2013-05-23", "resources": { "dummy": { "type": "dummy.resource", "properties": { "Foo": "baz" } }, "group1": { "type": "OS::Heat::ResourceGroup", "properties": { "count": 2, "resource_def": { "type": "dummy.resource", "properties": { "Foo": {"get_attr": ["dummy", "Foo"]} } } } } } } class ResourceWithPropsAndId(generic_resource.ResourceWithProps): def FnGetRefId(self): return "ID-%s" % self.name class ResourceGroupTest(common.HeatTestCase): def setUp(self): common.HeatTestCase.setUp(self) resource._register_class("dummy.resource", ResourceWithPropsAndId) utils.setup_dummy_db() def test_assemble_nested(self): """ Tests that the nested stack that implements the group is created appropriately based on properties. """ stack = utils.parse_stack(template) snip = stack.t['Resources']['group1'] resg = resource_group.ResourceGroup('test', snip, stack) templ = { "heat_template_version": "2013-05-23", "resources": { "0": { "type": "dummy.resource", "properties": { "Foo": "Bar" } }, "1": { "type": "dummy.resource", "properties": { "Foo": "Bar" } }, "2": { "type": "dummy.resource", "properties": { "Foo": "Bar" } } } } self.assertEqual(templ, resg._assemble_nested(3)) def test_assemble_nested_include(self): templ = copy.deepcopy(template) res_def = templ["resources"]["group1"]["properties"]['resource_def'] res_def['properties']['Foo'] = None stack = utils.parse_stack(templ) snip = stack.t['Resources']['group1'] resg = resource_group.ResourceGroup('test', snip, stack) expect = { "heat_template_version": "2013-05-23", "resources": { "0": { "type": "dummy.resource", "properties": {} } } } self.assertEqual(expect, resg._assemble_nested(1)) expect['resources']["0"]['properties'] = {"Foo": None} self.assertEqual(expect, resg._assemble_nested(1, include_all=True)) def test_assemble_no_properties(self): templ = copy.deepcopy(template) res_def = templ["resources"]["group1"]["properties"]['resource_def'] del res_def['properties'] stack = utils.parse_stack(templ) resg = stack.resources['group1'] self.assertIsNone(resg.validate()) def test_invalid_res_type(self): """Test that error raised for unknown resource type.""" tmp = copy.deepcopy(template) grp_props = tmp['resources']['group1']['properties'] grp_props['resource_def']['type'] = "idontexist" stack = utils.parse_stack(tmp) snip = stack.t['Resources']['group1'] resg = resource_group.ResourceGroup('test', snip, stack) exc = self.assertRaises(exception.StackValidationFailed, resg.validate) self.assertIn('Unknown resource Type', str(exc)) def test_reference_attr(self): stack = utils.parse_stack(template2) snip = stack.t['Resources']['group1'] resgrp = resource_group.ResourceGroup('test', snip, stack) self.assertIsNone(resgrp.validate()) @utils.stack_delete_after def test_delete(self): """Test basic delete.""" resg = self._create_dummy_stack() self.assertIsNotNone(resg.nested()) scheduler.TaskRunner(resg.delete)() self.assertEqual((resg.DELETE, resg.COMPLETE), resg.nested().state) self.assertEqual((resg.DELETE, resg.COMPLETE), resg.state) @utils.stack_delete_after def test_update(self): """Test basic update.""" resg = self._create_dummy_stack() new_snip = copy.deepcopy(resg.t) new_snip['Properties']['count'] = 3 scheduler.TaskRunner(resg.update, new_snip)() self.stack = resg.nested() self.assertEqual((resg.UPDATE, resg.COMPLETE), resg.state) self.assertEqual((resg.UPDATE, resg.COMPLETE), resg.nested().state) self.assertEqual(3, len(resg.nested())) @utils.stack_delete_after def test_aggregate_attribs(self): """ Test attribute aggregation and that we mimic the nested resource's attributes. """ resg = self._create_dummy_stack() expected = ['0', '1'] self.assertEqual(expected, resg.FnGetAtt('foo')) self.assertEqual(expected, resg.FnGetAtt('Foo')) @utils.stack_delete_after def test_aggregate_refs(self): """ Test resource id aggregation """ resg = self._create_dummy_stack() expected = ['ID-0', 'ID-1'] self.assertEqual(expected, resg.FnGetAtt("refs")) @utils.stack_delete_after def test_index_refs(self): """Tests getting ids of individual resources.""" resg = self._create_dummy_stack() self.assertEqual("ID-0", resg.FnGetAtt('resource.0')) self.assertEqual("ID-1", resg.FnGetAtt('resource.1')) self.assertRaises(exception.InvalidTemplateAttribute, resg.FnGetAtt, 'resource.2') def _create_dummy_stack(self): stack = utils.parse_stack(template) snip = stack.t['Resources']['group1'] resg = resource_group.ResourceGroup('test', snip, stack) scheduler.TaskRunner(resg.create)() self.stack = resg.nested() self.assertEqual(2, len(resg.nested())) self.assertEqual((resg.CREATE, resg.COMPLETE), resg.state) return resg def test_child_template(self): stack = utils.parse_stack(template2) snip = stack.t['Resources']['group1'] resgrp = resource_group.ResourceGroup('test', snip, stack) resgrp._assemble_nested = mock.Mock(return_value='tmpl') resgrp.properties.data[resgrp.COUNT] = 2 self.assertEqual('tmpl', resgrp.child_template()) resgrp._assemble_nested.assert_called_once_with(2) def test_child_params(self): stack = utils.parse_stack(template2) snip = stack.t['Resources']['group1'] resgrp = resource_group.ResourceGroup('test', snip, stack) self.assertEqual({}, resgrp.child_params()) heat-2014.1.5/heat/tests/test_neutron_loadbalancer.py0000664000567000056700000011674412540642614023723 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. import copy import mox from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.resources.neutron import loadbalancer from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils from heat.tests.v1_1 import fakes as nova_fakes neutronclient = try_import('neutronclient.v2_0.client') health_monitor_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer resources", "Parameters" : {}, "Resources" : { "monitor": { "Type": "OS::Neutron::HealthMonitor", "Properties": { "type": "HTTP", "delay": 3, "max_retries": 5, "timeout": 10 } } } } ''' pool_template_with_vip_subnet = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer resources", "Parameters" : {}, "Resources" : { "pool": { "Type": "OS::Neutron::Pool", "Properties": { "protocol": "HTTP", "subnet_id": "sub123", "lb_method": "ROUND_ROBIN", "vip": { "protocol_port": 80, "subnet": "sub9999" } } } } } ''' pool_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer resources", "Parameters" : {}, "Resources" : { "pool": { "Type": "OS::Neutron::Pool", "Properties": { "protocol": "HTTP", "subnet_id": "sub123", "lb_method": "ROUND_ROBIN", "vip": { "protocol_port": 80 } } } } } ''' member_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer member", "Resources" : { "member": { "Type": "OS::Neutron::PoolMember", "Properties": { "protocol_port": 8080, "pool_id": "pool123", "address": "1.2.3.4" } } } } ''' lb_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer resources", "Parameters" : {}, "Resources" : { "lb": { "Type": "OS::Neutron::LoadBalancer", "Properties": { "protocol_port": 8080, "pool_id": "pool123", "members": ["1234"] } } } } ''' pool_with_session_persistence_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer resources wit", "Parameters" : {}, "Resources" : { "pool": { "Type": "OS::Neutron::Pool", "Properties": { "protocol": "HTTP", "subnet_id": "sub123", "lb_method": "ROUND_ROBIN", "vip": { "protocol_port": 80, "session_persistence": { "type": "APP_COOKIE", "cookie_name": "cookie" } } } } } } ''' pool_with_health_monitors_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test load balancer resources", "Parameters" : {}, "Resources" : { "monitor1": { "Type": "OS::Neutron::HealthMonitor", "Properties": { "type": "HTTP", "delay": 3, "max_retries": 5, "timeout": 10 } }, "monitor2": { "Type": "OS::Neutron::HealthMonitor", "Properties": { "type": "HTTP", "delay": 3, "max_retries": 5, "timeout": 10 } }, "pool": { "Type": "OS::Neutron::Pool", "Properties": { "protocol": "HTTP", "subnet_id": "sub123", "lb_method": "ROUND_ROBIN", "vip": { "protocol_port": 80 }, "monitors": [ {"Ref": "monitor1"}, {"Ref": "monitor2"} ] } } } } ''' @skipIf(neutronclient is None, 'neutronclient unavailable') class HealthMonitorTest(HeatTestCase): def setUp(self): super(HealthMonitorTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'delete_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'show_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'update_health_monitor') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_health_monitor(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_health_monitor({ 'health_monitor': { 'delay': 3, 'max_retries': 5, 'type': u'HTTP', 'timeout': 10, 'admin_state_up': True}} ).AndReturn({'health_monitor': {'id': '5678'}}) snippet = template_format.parse(health_monitor_template) stack = utils.parse_stack(snippet) return loadbalancer.HealthMonitor( 'monitor', snippet['Resources']['monitor'], stack) def test_create(self): rsrc = self.create_health_monitor() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_health_monitor({ 'health_monitor': { 'delay': 3, 'max_retries': 5, 'type': u'HTTP', 'timeout': 10, 'admin_state_up': True}} ).AndRaise(loadbalancer.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(health_monitor_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.HealthMonitor( 'monitor', snippet['Resources']['monitor'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete(self): neutronclient.Client.delete_health_monitor('5678') neutronclient.Client.show_health_monitor('5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) rsrc = self.create_health_monitor() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_health_monitor('5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) rsrc = self.create_health_monitor() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_health_monitor('5678').AndRaise( loadbalancer.NeutronClientException(status_code=400)) rsrc = self.create_health_monitor() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_health_monitor() neutronclient.Client.show_health_monitor('5678').MultipleTimes( ).AndReturn( {'health_monitor': {'admin_state_up': True, 'delay': 3}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertIs(True, rsrc.FnGetAtt('admin_state_up')) self.assertEqual(3, rsrc.FnGetAtt('delay')) self.m.VerifyAll() def test_attribute_failed(self): rsrc = self.create_health_monitor() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'subnet_id') self.assertEqual( 'The Referenced Attribute (monitor subnet_id) is incorrect.', str(error)) self.m.VerifyAll() def test_update(self): rsrc = self.create_health_monitor() neutronclient.Client.update_health_monitor( '5678', {'health_monitor': {'delay': 10}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['delay'] = 10 scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class PoolTest(HeatTestCase): def setUp(self): super(PoolTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_pool') self.m.StubOutWithMock(neutronclient.Client, 'delete_pool') self.m.StubOutWithMock(neutronclient.Client, 'show_pool') self.m.StubOutWithMock(neutronclient.Client, 'update_pool') self.m.StubOutWithMock(neutronclient.Client, 'associate_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'disassociate_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'create_vip') self.m.StubOutWithMock(loadbalancer.neutronV20, 'find_resourceid_by_name_or_id') self.m.StubOutWithMock(neutronclient.Client, 'delete_vip') self.m.StubOutWithMock(neutronclient.Client, 'show_vip') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_pool(self, with_vip_subnet=False): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) stvipvsn = { 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub9999', 'pool_id': '5678', 'protocol_port': 80} } stvippsn = copy.deepcopy(stvipvsn) stvippsn['vip']['subnet_id'] = 'sub123' if with_vip_subnet: neutronclient.Client.create_vip(stvipvsn ).AndReturn({'vip': {'id': 'xyz'}}) snippet = template_format.parse(pool_template_with_vip_subnet) else: neutronclient.Client.create_vip(stvippsn ).AndReturn({'vip': {'id': 'xyz'}}) snippet = template_format.parse(pool_template) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) stack = utils.parse_stack(snippet) return loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) def test_create(self): rsrc = self.create_pool() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_with_vip_subnet(self): loadbalancer.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub9999' ).AndReturn('sub9999') rsrc = self.create_pool(with_vip_subnet=True) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_pending(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'PENDING_CREATE'}}) neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'PENDING_CREATE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed_unexpected_status(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ERROR', 'name': '5678'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) self.m.ReplayAll() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'Error: neutron reported unexpected pool ' 'resource[5678] status[ERROR]', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_create_failed_unexpected_vip_status(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ERROR', 'name': 'xyz'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) self.m.ReplayAll() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'Error: neutron reported unexpected vip ' 'resource[xyz] status[ERROR]', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndRaise(loadbalancer.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_create_with_session_persistence(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80, 'session_persistence': { 'type': 'APP_COOKIE', 'cookie_name': 'cookie'}}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) snippet = template_format.parse(pool_with_session_persistence_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_failing_validation_with_session_persistence(self): msg = _('Property cookie_name is required, when ' 'session_persistence type is set to APP_COOKIE.') snippet = template_format.parse(pool_with_session_persistence_template) pool = snippet['Resources']['pool'] persistence = pool['Properties']['vip']['session_persistence'] # When persistence type is set to APP_COOKIE, cookie_name is required persistence['type'] = 'APP_COOKIE' persistence['cookie_name'] = None resource = loadbalancer.Pool('pool', pool, utils.parse_stack(snippet)) error = self.assertRaises(exception.StackValidationFailed, resource.validate) self.assertEqual(msg, str(error)) def test_validation_not_failing_without_session_persistence(self): snippet = template_format.parse(pool_template) pool = snippet['Resources']['pool'] resource = loadbalancer.Pool('pool', pool, utils.parse_stack(snippet)) self.assertIsNone(resource.validate()) def test_properties_are_prepared_for_session_persistence(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80, 'session_persistence': {'type': 'HTTP_COOKIE'}}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) snippet = template_format.parse(pool_with_session_persistence_template) pool = snippet['Resources']['pool'] persistence = pool['Properties']['vip']['session_persistence'] # change persistence type to HTTP_COOKIE that not require cookie_name persistence['type'] = 'HTTP_COOKIE' del persistence['cookie_name'] resource = loadbalancer.Pool('pool', pool, utils.parse_stack(snippet)) # assert that properties contain cookie_name property with None value persistence = resource.properties['vip']['session_persistence'] self.assertIn('cookie_name', persistence) self.assertIsNone(persistence['cookie_name']) self.m.ReplayAll() scheduler.TaskRunner(resource.create)() self.assertEqual((resource.CREATE, resource.COMPLETE), resource.state) self.m.VerifyAll() def test_delete(self): rsrc = self.create_pool() neutronclient.Client.delete_vip('xyz') neutronclient.Client.show_vip('xyz').AndRaise( loadbalancer.NeutronClientException(status_code=404)) neutronclient.Client.delete_pool('5678') neutronclient.Client.show_pool('5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_vip('xyz').AndRaise( loadbalancer.NeutronClientException(status_code=404)) neutronclient.Client.delete_pool('5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) rsrc = self.create_pool() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_vip_failed(self): neutronclient.Client.delete_vip('xyz').AndRaise( loadbalancer.NeutronClientException(status_code=400)) rsrc = self.create_pool() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_vip('xyz').AndRaise( loadbalancer.NeutronClientException(status_code=404)) neutronclient.Client.delete_pool('5678').AndRaise( loadbalancer.NeutronClientException(status_code=400)) rsrc = self.create_pool() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_pool() neutronclient.Client.show_pool('5678').MultipleTimes( ).AndReturn( {'pool': {'admin_state_up': True, 'lb_method': 'ROUND_ROBIN'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertIs(True, rsrc.FnGetAtt('admin_state_up')) self.assertEqual('ROUND_ROBIN', rsrc.FnGetAtt('lb_method')) self.m.VerifyAll() def test_vip_attribute(self): rsrc = self.create_pool() neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'address': '10.0.0.3', 'name': 'xyz'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual({'address': '10.0.0.3', 'name': 'xyz'}, rsrc.FnGetAtt('vip')) self.m.VerifyAll() def test_attribute_failed(self): rsrc = self.create_pool() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'net_id') self.assertEqual( 'The Referenced Attribute (pool net_id) is incorrect.', str(error)) self.m.VerifyAll() def test_update(self): rsrc = self.create_pool() neutronclient.Client.update_pool( '5678', {'pool': {'admin_state_up': False}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['admin_state_up'] = False scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() def test_update_monitors(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.associate_health_monitor( '5678', {'health_monitor': {'id': 'mon123'}}) neutronclient.Client.associate_health_monitor( '5678', {'health_monitor': {'id': 'mon456'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) neutronclient.Client.disassociate_health_monitor( '5678', 'mon456') neutronclient.Client.associate_health_monitor( '5678', {'health_monitor': {'id': 'mon789'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) snippet['Resources']['pool']['Properties']['monitors'] = [ 'mon123', 'mon456'] rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['monitors'] = ['mon123', 'mon789'] scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class PoolMemberTest(HeatTestCase): def setUp(self): super(PoolMemberTest, self).setUp() self.fc = nova_fakes.FakeClient() self.m.StubOutWithMock(neutronclient.Client, 'create_member') self.m.StubOutWithMock(neutronclient.Client, 'delete_member') self.m.StubOutWithMock(neutronclient.Client, 'update_member') self.m.StubOutWithMock(neutronclient.Client, 'show_member') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_member(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_member({ 'member': { 'pool_id': 'pool123', 'protocol_port': 8080, 'address': '1.2.3.4', 'admin_state_up': True}} ).AndReturn({'member': {'id': 'member5678'}}) snippet = template_format.parse(member_template) stack = utils.parse_stack(snippet) return loadbalancer.PoolMember( 'member', snippet['Resources']['member'], stack) def test_create(self): rsrc = self.create_member() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('member5678', rsrc.resource_id) self.m.VerifyAll() def test_create_optional_parameters(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_member({ 'member': { 'pool_id': 'pool123', 'protocol_port': 8080, 'weight': 100, 'admin_state_up': False, 'address': '1.2.3.4'}} ).AndReturn({'member': {'id': 'member5678'}}) snippet = template_format.parse(member_template) snippet['Resources']['member']['Properties']['admin_state_up'] = False snippet['Resources']['member']['Properties']['weight'] = 100 stack = utils.parse_stack(snippet) rsrc = loadbalancer.PoolMember( 'member', snippet['Resources']['member'], stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('member5678', rsrc.resource_id) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_member() neutronclient.Client.show_member('member5678').MultipleTimes( ).AndReturn( {'member': {'admin_state_up': True, 'weight': 5}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertIs(True, rsrc.FnGetAtt('admin_state_up')) self.assertEqual(5, rsrc.FnGetAtt('weight')) self.m.VerifyAll() def test_update(self): rsrc = self.create_member() neutronclient.Client.update_member( 'member5678', {'member': {'pool_id': 'pool456'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['pool_id'] = 'pool456' scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() def test_delete(self): rsrc = self.create_member() neutronclient.Client.delete_member(u'member5678') neutronclient.Client.show_member(u'member5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_missing_member(self): rsrc = self.create_member() neutronclient.Client.delete_member(u'member5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class LoadBalancerTest(HeatTestCase): def setUp(self): super(LoadBalancerTest, self).setUp() self.fc = nova_fakes.FakeClient() self.m.StubOutWithMock(neutronclient.Client, 'create_member') self.m.StubOutWithMock(neutronclient.Client, 'delete_member') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') self.m.StubOutWithMock(clients.OpenStackClients, 'nova') utils.setup_dummy_db() def create_load_balancer(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) clients.OpenStackClients.nova("compute").MultipleTimes().AndReturn( self.fc) neutronclient.Client.create_member({ 'member': { 'pool_id': 'pool123', 'protocol_port': 8080, 'address': '1.2.3.4'}} ).AndReturn({'member': {'id': 'member5678'}}) snippet = template_format.parse(lb_template) stack = utils.parse_stack(snippet) return loadbalancer.LoadBalancer( 'lb', snippet['Resources']['lb'], stack) def test_create(self): rsrc = self.create_load_balancer() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_update(self): rsrc = self.create_load_balancer() neutronclient.Client.delete_member(u'member5678') neutronclient.Client.create_member({ 'member': { 'pool_id': 'pool123', 'protocol_port': 8080, 'address': '4.5.6.7'}} ).AndReturn({'member': {'id': 'memberxyz'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['members'] = ['5678'] scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() def test_update_missing_member(self): rsrc = self.create_load_balancer() neutronclient.Client.delete_member(u'member5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['members'] = [] scheduler.TaskRunner(rsrc.update, update_template)() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete(self): rsrc = self.create_load_balancer() neutronclient.Client.delete_member(u'member5678') self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_missing_member(self): rsrc = self.create_load_balancer() neutronclient.Client.delete_member(u'member5678').AndRaise( loadbalancer.NeutronClientException(status_code=404)) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class PoolUpdateHealthMonitorsTest(HeatTestCase): def setUp(self): super(PoolUpdateHealthMonitorsTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_pool') self.m.StubOutWithMock(neutronclient.Client, 'delete_pool') self.m.StubOutWithMock(neutronclient.Client, 'show_pool') self.m.StubOutWithMock(neutronclient.Client, 'update_pool') self.m.StubOutWithMock(neutronclient.Client, 'associate_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'disassociate_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'create_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'delete_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'show_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'update_health_monitor') self.m.StubOutWithMock(neutronclient.Client, 'create_vip') self.m.StubOutWithMock(neutronclient.Client, 'delete_vip') self.m.StubOutWithMock(neutronclient.Client, 'show_vip') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() @utils.stack_delete_after def test_update_pool_with_references_to_health_monitors(self): clients.OpenStackClients.keystone().MultipleTimes().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_health_monitor({ 'health_monitor': { 'delay': 3, 'max_retries': 5, 'type': u'HTTP', 'timeout': 10, 'admin_state_up': True}} ).AndReturn({'health_monitor': {'id': '5555'}}) neutronclient.Client.create_health_monitor({ 'health_monitor': { 'delay': 3, 'max_retries': 5, 'type': u'HTTP', 'timeout': 10, 'admin_state_up': True}} ).AndReturn({'health_monitor': {'id': '6666'}}) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.associate_health_monitor( '5678', {'health_monitor': {'id': '5555'}}).InAnyOrder() neutronclient.Client.associate_health_monitor( '5678', {'health_monitor': {'id': '6666'}}).InAnyOrder() neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) neutronclient.Client.disassociate_health_monitor( '5678', mox.IsA(unicode)) self.m.ReplayAll() snippet = template_format.parse(pool_with_health_monitors_template) self.stack = utils.parse_stack(snippet) self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) snippet['Resources']['pool']['Properties']['monitors'] = [ {u'Ref': u'monitor1'}] updated_stack = utils.parse_stack(snippet) self.stack.update(updated_stack) self.assertEqual((self.stack.UPDATE, self.stack.COMPLETE), self.stack.state) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_nova_utils.py0000664000567000056700000002375712540642614021726 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. """Tests for :module:'heat.engine.resources.nova_utls'.""" import mock import uuid from heat.common import exception from heat.engine import clients from heat.engine.resources import nova_utils from heat.tests.common import HeatTestCase from heat.tests.v1_1 import fakes class NovaUtilsTests(HeatTestCase): """ Basic tests for the helper methods in :module:'heat.engine.resources.nova_utils'. """ def setUp(self): super(NovaUtilsTests, self).setUp() self.nova_client = self.m.CreateMockAnything() def test_get_image_id(self): """Tests the get_image_id function.""" my_image = self.m.CreateMockAnything() img_id = str(uuid.uuid4()) img_name = 'myfakeimage' my_image.id = img_id my_image.name = img_name self.nova_client.images = self.m.CreateMockAnything() self.nova_client.images.get(img_id).AndReturn(my_image) self.nova_client.images.list().MultipleTimes().AndReturn([my_image]) self.m.ReplayAll() self.assertEqual(img_id, nova_utils.get_image_id(self.nova_client, img_id)) self.assertEqual(img_id, nova_utils.get_image_id(self.nova_client, 'myfakeimage')) self.assertRaises(exception.ImageNotFound, nova_utils.get_image_id, self.nova_client, 'noimage') self.m.VerifyAll() def test_get_ip(self): my_image = self.m.CreateMockAnything() my_image.addresses = { 'public': [{'version': 4, 'addr': '4.5.6.7'}, {'version': 6, 'addr': '2401:1801:7800:0101:c058:dd33:ff18:04e6'}], 'private': [{'version': 4, 'addr': '10.13.12.13'}]} expected = '4.5.6.7' observed = nova_utils.get_ip(my_image, 'public', 4) self.assertEqual(expected, observed) expected = '10.13.12.13' observed = nova_utils.get_ip(my_image, 'private', 4) self.assertEqual(expected, observed) expected = '2401:1801:7800:0101:c058:dd33:ff18:04e6' observed = nova_utils.get_ip(my_image, 'public', 6) self.assertEqual(expected, observed) def test_get_flavor_id(self): """Tests the get_flavor_id function.""" flav_id = str(uuid.uuid4()) flav_name = 'X-Large' my_flavor = self.m.CreateMockAnything() my_flavor.name = flav_name my_flavor.id = flav_id self.nova_client.flavors = self.m.CreateMockAnything() self.nova_client.flavors.list().MultipleTimes().AndReturn([my_flavor]) self.m.ReplayAll() self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_name)) self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_id)) self.assertRaises(exception.FlavorMissing, nova_utils.get_flavor_id, self.nova_client, 'noflavor') self.m.VerifyAll() def test_get_keypair(self): """Tests the get_keypair function.""" my_pub_key = 'a cool public key string' my_key_name = 'mykey' my_key = self.m.CreateMockAnything() my_key.public_key = my_pub_key my_key.name = my_key_name self.nova_client.keypairs = self.m.CreateMockAnything() self.nova_client.keypairs.list().MultipleTimes().AndReturn([my_key]) self.m.ReplayAll() self.assertEqual(my_key, nova_utils.get_keypair(self.nova_client, my_key_name)) self.assertRaises(exception.UserKeyPairMissing, nova_utils.get_keypair, self.nova_client, 'notakey') self.m.VerifyAll() class NovaUtilsRefreshServerTests(HeatTestCase): def test_successful_refresh(self): server = self.m.CreateMockAnything() server.get().AndReturn(None) self.m.ReplayAll() self.assertIsNone(nova_utils.refresh_server(server)) self.m.VerifyAll() def test_overlimit_error(self): server = mock.Mock() server.get.side_effect = clients.novaclient.exceptions.OverLimit( 413, "limit reached") self.assertIsNone(nova_utils.refresh_server(server)) def test_500_error(self): server = self.m.CreateMockAnything() server.get().AndRaise(fakes.fake_exception(500)) self.m.ReplayAll() self.assertIsNone(nova_utils.refresh_server(server)) self.m.VerifyAll() def test_503_error(self): server = self.m.CreateMockAnything() server.get().AndRaise(fakes.fake_exception(503)) self.m.ReplayAll() self.assertIsNone(nova_utils.refresh_server(server)) self.m.VerifyAll() def test_unhandled_exception(self): server = self.m.CreateMockAnything() msg = ("ClientException: The server has either erred or is " "incapable of performing the requested operation.") server.get().AndRaise( clients.novaclient.exceptions.ClientException(501, msg)) self.m.ReplayAll() self.assertRaises(clients.novaclient.exceptions.ClientException, nova_utils.refresh_server, server) self.m.VerifyAll() class NovaUtilsUserdataTests(HeatTestCase): def setUp(self): super(NovaUtilsUserdataTests, self).setUp() self.nova_client = self.m.CreateMockAnything() def test_build_userdata(self): """Tests the build_userdata function.""" resource = self.m.CreateMockAnything() resource.metadata = {} self.m.StubOutWithMock(nova_utils.cfg, 'CONF') cnf = nova_utils.cfg.CONF cnf.heat_metadata_server_url = 'http://server.test:123' cnf.heat_watch_server_url = 'http://server.test:345' cnf.instance_connection_is_secure = False cnf.instance_connection_https_validate_certificates = False self.m.ReplayAll() data = nova_utils.build_userdata(resource) self.assertIn("Content-Type: text/cloud-config;", data) self.assertIn("Content-Type: text/cloud-boothook;", data) self.assertIn("Content-Type: text/part-handler;", data) self.assertIn("Content-Type: text/x-cfninitdata;", data) self.assertIn("Content-Type: text/x-shellscript;", data) self.assertIn("http://server.test:345", data) self.assertIn("http://server.test:123", data) self.assertIn("[Boto]", data) self.m.VerifyAll() def test_build_userdata_without_instance_user(self): """Don't add a custom instance user when not requested.""" resource = self.m.CreateMockAnything() resource.metadata = {} self.m.StubOutWithMock(nova_utils.cfg, 'CONF') cnf = nova_utils.cfg.CONF cnf.instance_user = 'config_instance_user' cnf.heat_metadata_server_url = 'http://server.test:123' cnf.heat_watch_server_url = 'http://server.test:345' self.m.ReplayAll() data = nova_utils.build_userdata(resource, instance_user=None) self.assertNotIn('user: ', data) self.assertNotIn('useradd', data) self.assertNotIn('config_instance_user', data) self.m.VerifyAll() def test_build_userdata_with_instance_user(self): """Add the custom instance user when requested.""" resource = self.m.CreateMockAnything() resource.metadata = {} self.m.StubOutWithMock(nova_utils.cfg, 'CONF') cnf = nova_utils.cfg.CONF cnf.instance_user = 'config_instance_user' cnf.heat_metadata_server_url = 'http://server.test:123' cnf.heat_watch_server_url = 'http://server.test:345' self.m.ReplayAll() data = nova_utils.build_userdata(resource, instance_user="custominstanceuser") self.assertNotIn('config_instance_user', data) self.assertIn("custominstanceuser", data) self.m.VerifyAll() class NovaUtilsMetadataTests(HeatTestCase): def test_serialize_string(self): original = {'test_key': 'simple string value'} self.assertEqual(original, nova_utils.meta_serialize(original)) def test_serialize_int(self): original = {'test_key': 123} expected = {'test_key': '123'} self.assertEqual(expected, nova_utils.meta_serialize(original)) def test_serialize_list(self): original = {'test_key': [1, 2, 3]} expected = {'test_key': '[1, 2, 3]'} self.assertEqual(expected, nova_utils.meta_serialize(original)) def test_serialize_dict(self): original = {'test_key': {'a': 'b', 'c': 'd'}} expected = {'test_key': '{"a": "b", "c": "d"}'} self.assertEqual(expected, nova_utils.meta_serialize(original)) def test_serialize_none(self): original = {'test_key': None} expected = {'test_key': 'null'} self.assertEqual(expected, nova_utils.meta_serialize(original)) def test_serialize_combined(self): original = { 'test_key_1': 123, 'test_key_2': 'a string', 'test_key_3': {'a': 'b'}, 'test_key_4': None, } expected = { 'test_key_1': '123', 'test_key_2': 'a string', 'test_key_3': '{"a": "b"}', 'test_key_4': 'null', } self.assertEqual(expected, nova_utils.meta_serialize(original)) heat-2014.1.5/heat/tests/test_neutron_autoscaling.py0000664000567000056700000003127412540642614023617 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. import copy import uuid import mox from oslo.config import cfg from testtools import skipIf from heat.common import template_format from heat.db import api as db_api from heat.engine import clients from heat.engine import environment from heat.engine import parser from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import nova_utils from heat.engine import template from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils from heat.tests.v1_1 import fakes as v1fakes neutroncli = try_import('neutronclient') as_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "AutoScaling Test", "Parameters" : { "ImageId": {"Type": "String"}, "KeyName": {"Type": "String"}, "SubnetId": {"Type": "String"} }, "Resources" : { "SvrGrp" : { "Type" : "AWS::AutoScaling::AutoScalingGroup", "Properties" : { "AvailabilityZones" : ["nova"], "LaunchConfigurationName" : { "Ref" : "LaunchConfig" }, "MinSize" : "1", "MaxSize" : "5", "DesiredCapacity": "1", "VPCZoneIdentifier": [ { "Ref": "SubnetId" } ], "LoadBalancerNames" : [ { "Ref" : "ElasticLoadBalancer" } ] } }, "myMonitor": { "Type": "OS::Neutron::HealthMonitor", "Properties": { "type": "HTTP", "delay": 3, "max_retries": 5, "timeout": 10 } }, "myPool": { "Type": "OS::Neutron::Pool", "Properties": { "description": "Test Pool", "lb_method": "ROUND_ROBIN", "monitors": [ { "Ref": "myMonitor" } ], "name": "Test_Pool", "protocol": "HTTP", "subnet_id": { "Ref": "SubnetId" }, "vip": { "description": "Test VIP", "connection_limit": 1000, "address": "10.0.3.121", "protocol_port": 80, "name": "test_vip" } } }, "ElasticLoadBalancer" : { 'Type': 'OS::Neutron::LoadBalancer', 'Properties': { 'protocol_port': 8080, 'pool_id': { "Ref": "myPool" } } }, "LaunchConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : {"Ref": "ImageId"}, "InstanceType" : "bar", } } } } ''' class AutoScalingTest(HeatTestCase): params = {'KeyName': 'test', 'ImageId': 'foo'} def setUp(self): super(AutoScalingTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() self.fc = v1fakes.FakeClient() cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') self.m.StubOutWithMock(clients.neutronclient.Client, 'create_health_monitor') self.m.StubOutWithMock(clients.neutronclient.Client, 'associate_health_monitor') self.m.StubOutWithMock(clients.neutronclient.Client, 'create_pool') self.m.StubOutWithMock(clients.neutronclient.Client, 'create_vip') self.m.StubOutWithMock(clients.neutronclient.Client, 'show_pool') self.m.StubOutWithMock(clients.neutronclient.Client, 'show_vip') self.m.StubOutWithMock(clients.neutronclient.Client, 'create_member') self.m.StubOutWithMock(clients.neutronclient.Client, 'list_members') self.m.StubOutWithMock(nova_utils, 'server_to_ipaddress') self.m.StubOutWithMock(parser.Stack, 'validate') self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') self.m.StubOutWithMock(image.ImageConstraint, "validate") @skipIf(neutroncli is None, 'neutronclient unavailable') def test_lb(self): tmpl = template_format.parse(as_template) network_body = { "network": { "id": str(uuid.uuid4()), "name": "testnet", "admin_state_up": True } } subnet_body = { "subnet": { "name": "testsubnet", "id": str(uuid.uuid4()), "network_id": network_body['network']['id'], "ip_version": 4, "cidr": "10.0.3.0/24", "allocation_pools": [ { "start": "10.0.3.20", "end": "10.0.3.150" } ], "gateway_ip": "10.0.3.1" } } self.params["SubnetId"] = subnet_body['subnet']['id'] mon_block = { 'health_monitor': tmpl['Resources']['myMonitor']['Properties'] } mon_block['health_monitor']['admin_state_up'] = True mon_ret_block = copy.deepcopy(mon_block) mon_ret_block['health_monitor']['id'] = str(uuid.uuid4()) mon_ret_block['health_monitor']['status'] = 'ACTIVE' pool_block = {'pool': {}} tmp_pool_block = tmpl['Resources']['myPool']['Properties'] for val in ['lb_method', 'protocol', 'name', 'description']: pool_block['pool'][val] = tmp_pool_block[val] pool_block['pool']['admin_state_up'] = True pool_block['pool']['subnet_id'] = self.params['SubnetId'] pool_block['pool']['admin_state_up'] = True pool_ret_block = copy.deepcopy(pool_block) pool_ret_block['pool']['id'] = str(uuid.uuid4()) pool_ret_block['pool']['status'] = 'ACTIVE' tmp_vip_block = tmp_pool_block.pop('vip') vip_block = { 'vip': { 'protocol': pool_block['pool']['protocol'], 'description': tmp_vip_block['description'], 'admin_state_up': True, 'subnet_id': self.params['SubnetId'], 'connection_limit': tmp_vip_block['connection_limit'], 'pool_id': pool_ret_block['pool']['id'], 'address': tmp_vip_block['address'], 'protocol_port': tmp_vip_block['protocol_port'], 'name': tmp_vip_block['name'] } } vip_ret_block = copy.deepcopy(vip_block) vip_ret_block['vip']['id'] = str(uuid.uuid4()) vip_ret_block['vip']['status'] = 'ACTIVE' port_block = { 'port': { 'network_id': network_body['network']['id'], 'fixed_ips': [ { 'subnet_id': subnet_body['subnet']['id'], } ], 'admin_state_up': True } } port_ret_block = copy.deepcopy(port_block) port_ret_block['port']['id'] = str(uuid.uuid4()) membera_block = { 'member': { 'protocol_port': 8080, 'pool_id': pool_ret_block['pool']['id'], 'address': '1.2.3.4' } } membera_ret_block = copy.deepcopy(membera_block) membera_ret_block['member']['id'] = str(uuid.uuid4()) memberb_block = { 'member': { 'protocol_port': 8080, 'pool_id': pool_ret_block['pool']['id'], 'address': '1.2.3.5' } } memberb_ret_block = copy.deepcopy(memberb_block) memberb_ret_block['member']['id'] = str(uuid.uuid4()) memberc_block = { 'member': { 'protocol_port': 8080, 'pool_id': pool_ret_block['pool']['id'], 'address': '1.2.3.6' } } memberc_ret_block = copy.deepcopy(memberc_block) memberc_ret_block['member']['id'] = str(uuid.uuid4()) class id_type(object): def __init__(self, id, name): self.id = id self.name = name instances = {} clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) clients.neutronclient.Client.create_health_monitor(mon_block).\ AndReturn(mon_ret_block) clients.neutronclient.Client.create_pool(pool_block).\ AndReturn(pool_ret_block) clients.neutronclient.Client.associate_health_monitor( pool_ret_block['pool']['id'], {'health_monitor': { 'id': mon_ret_block['health_monitor']['id'] }}).AndReturn(None) clients.neutronclient.Client.create_vip(vip_block).\ AndReturn(vip_ret_block) clients.neutronclient.Client.show_pool(pool_ret_block['pool']['id']).\ AndReturn(pool_ret_block) clients.neutronclient.Client.show_vip(vip_ret_block['vip']['id']).\ AndReturn(vip_ret_block) clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) parser.Stack.validate() instid = str(uuid.uuid4()) instance.Instance.handle_create().AndReturn(instid) instance.Instance.check_create_complete(mox.IgnoreArg())\ .AndReturn(False) instance.Instance.check_create_complete(mox.IgnoreArg())\ .AndReturn(True) image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) nova_utils.server_to_ipaddress( mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('1.2.3.4') clients.neutronclient.Client.create_member(membera_block).\ AndReturn(membera_ret_block) instances[instid] = membera_ret_block['member']['id'] # Start of update clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) parser.Stack.validate() instid = str(uuid.uuid4()) instance.Instance.handle_create().AndReturn(instid) instance.Instance.check_create_complete(mox.IgnoreArg())\ .AndReturn(False) instance.Instance.check_create_complete(mox.IgnoreArg())\ .AndReturn(True) instances[instid] = memberb_ret_block['member']['id'] instid = str(uuid.uuid4()) instance.Instance.handle_create().AndReturn(instid) instance.Instance.check_create_complete(mox.IgnoreArg())\ .AndReturn(False) instance.Instance.check_create_complete(mox.IgnoreArg())\ .AndReturn(True) nova_utils.server_to_ipaddress( mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('1.2.3.5') clients.neutronclient.Client.create_member(memberb_block).\ AndReturn(memberb_ret_block) nova_utils.server_to_ipaddress( mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('1.2.3.6') clients.neutronclient.Client.create_member(memberc_block).\ AndReturn(memberc_ret_block) self.m.ReplayAll() # Start of stack create env = {'parameters': self.params} tmpl = template_format.parse(as_template) stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), environment.Environment(env)) stack.store() stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), stack.state) # Start of stack update stack2 = parser.Stack.load(self.ctx, stack_id=stack.id) tmpl2 = copy.deepcopy(tmpl) tmpl2['Resources']['SvrGrp']['Properties']['DesiredCapacity'] = '3' update_stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl2), environment.Environment(env)) stack2.update(update_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), stack2.state) members = db_api.resource_data_get_all(stack['ElasticLoadBalancer']) self.assertEqual(3, len(members.keys())) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_auth_password.py0000664000567000056700000001073512540642614022416 0ustar jenkinsjenkins00000000000000 # Copyright 2013 OpenStack Foundation # # 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. from keystoneclient.exceptions import Unauthorized from keystoneclient.v2_0 import client as keystone_client import webob from heat.common.auth_password import KeystonePasswordAuthProtocol from heat.tests.common import HeatTestCase EXPECTED_V2_DEFAULT_ENV_RESPONSE = { 'HTTP_X_IDENTITY_STATUS': 'Confirmed', 'HTTP_X_TENANT_ID': 'tenant_id1', 'HTTP_X_TENANT_NAME': 'tenant_name1', 'HTTP_X_USER_ID': 'user_id1', 'HTTP_X_USER_NAME': 'user_name1', 'HTTP_X_ROLES': 'role1,role2', 'HTTP_X_USER': 'user_name1', # deprecated (diablo-compat) 'HTTP_X_TENANT': 'tenant_name1', # deprecated (diablo-compat) 'HTTP_X_ROLE': 'role1,role2', # deprecated (diablo-compat) } TOKEN_RESPONSE = { 'token': { 'id': 'lalalalalala', 'expires': '2020-01-01T00:00:10.000123Z', 'tenant': { 'id': 'tenant_id1', 'name': 'tenant_name1', }, }, 'user': { 'id': 'user_id1', 'name': 'user_name1', 'roles': [ {'name': 'role1'}, {'name': 'role2'}, ], }, 'serviceCatalog': {} } class FakeApp(object): """This represents a WSGI app protected by our auth middleware.""" def __init__(self, expected_env=None): expected_env = expected_env or {} self.expected_env = dict(EXPECTED_V2_DEFAULT_ENV_RESPONSE) self.expected_env.update(expected_env) def __call__(self, env, start_response): """Assert that expected environment is present when finally called.""" for k, v in self.expected_env.items(): assert env[k] == v, '%s != %s' % (env[k], v) resp = webob.Response() resp.body = 'SUCCESS' return resp(env, start_response) class KeystonePasswordAuthProtocolTest(HeatTestCase): def setUp(self): super(KeystonePasswordAuthProtocolTest, self).setUp() self.config = {'auth_uri': 'http://keystone.test.com:5000'} self.app = FakeApp( expected_env={'HTTP_X_AUTH_URL': self.config['auth_uri']}) self.middleware = KeystonePasswordAuthProtocol(self.app, self.config) def _start_fake_response(self, status, headers): self.response_status = int(status.split(' ', 1)[0]) self.response_headers = dict(headers) def test_valid_request(self): mock_client = self.m.CreateMock(keystone_client.Client) self.m.StubOutWithMock(keystone_client, 'Client') keystone_client.Client( username='user_name1', password='goodpassword', tenant_id='tenant_id1', auth_url=self.config['auth_uri']).AndReturn(mock_client) mock_client.auth_ref = TOKEN_RESPONSE self.m.ReplayAll() req = webob.Request.blank('/tenant_id1/') req.headers['X_AUTH_USER'] = 'user_name1' req.headers['X_AUTH_KEY'] = 'goodpassword' req.headers['X_AUTH_URL'] = self.config['auth_uri'] self.middleware(req.environ, self._start_fake_response) self.m.VerifyAll() def test_request_with_bad_credentials(self): self.m.StubOutWithMock( keystone_client, 'Client', use_mock_anything=True) mock_client = keystone_client.Client( username='user_name1', password='badpassword', tenant_id='tenant_id1', auth_url=self.config['auth_uri']) mock_client.AndRaise(Unauthorized(401)) self.m.ReplayAll() req = webob.Request.blank('/tenant_id1/') req.headers['X_AUTH_USER'] = 'user_name1' req.headers['X_AUTH_KEY'] = 'badpassword' req.headers['X_AUTH_URL'] = self.config['auth_uri'] self.middleware(req.environ, self._start_fake_response) self.m.VerifyAll() self.assertEqual(401, self.response_status) def test_request_with_no_tenant_in_url_or_auth_headers(self): req = webob.Request.blank('/') self.middleware(req.environ, self._start_fake_response) self.assertEqual(401, self.response_status) heat-2014.1.5/heat/tests/db/0000775000567000056700000000000012540643116016477 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/db/__init__.py0000664000567000056700000000000012540642611020575 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/db/test_migrations.py0000664000567000056700000002360512540642614022274 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. """ Tests for database migrations. This test case reads the configuration file test_migrations.conf for database connection settings to use in the tests. For each connection found in the config file, the test case runs a series of test cases to ensure that migrations work properly both upgrading and downgrading, and that no data loss occurs if possible. """ import datetime import os import shutil import subprocess import tempfile import uuid from migrate.versioning import repository import sqlalchemy from heat.db.sqlalchemy import migrate_repo from heat.db.sqlalchemy import migration from heat.openstack.common.db.sqlalchemy import test_migrations from heat.openstack.common import log as logging from heat.openstack.common.py3kcompat import urlutils LOG = logging.getLogger(__name__) def get_table(engine, name): """Returns an sqlalchemy table dynamically from db. Needed because the models don't work for us in migrations as models will be far out of sync with the current data. """ metadata = sqlalchemy.MetaData() metadata.bind = engine return sqlalchemy.Table(name, metadata, autoload=True) class TestHeatMigrations(test_migrations.BaseMigrationTestCase, test_migrations.WalkVersionsMixin): """Test sqlalchemy-migrate migrations.""" def __init__(self, *args, **kwargs): super(TestHeatMigrations, self).__init__(*args, **kwargs) self.DEFAULT_CONFIG_FILE = os.path.join(os.path.dirname(__file__), 'test_migrations.conf') # Test machines can set the TEST_MIGRATIONS_CONF variable # to override the location of the config file for migration testing self.CONFIG_FILE_PATH = os.environ.get('TEST_MIGRATIONS_CONF', self.DEFAULT_CONFIG_FILE) self.MIGRATE_FILE = migrate_repo.__file__ self.REPOSITORY = repository.Repository( os.path.abspath(os.path.dirname(self.MIGRATE_FILE))) def setUp(self): lock_dir = tempfile.mkdtemp() os.environ["HEAT_LOCK_PATH"] = lock_dir super(TestHeatMigrations, self).setUp() def clean_lock_dir(): shutil.rmtree(lock_dir, ignore_errors=True) self.addCleanup(clean_lock_dir) self.snake_walk = False self.downgrade = False self.INIT_VERSION = migration.INIT_VERSION if self.migration_api is None: temp = __import__('heat.openstack.common.db.sqlalchemy.migration', globals(), locals(), ['versioning_api'], -1) self.migration_api = temp.versioning_api def test_walk_versions(self): for key, engine in self.engines.items(): self._walk_versions(engine, self.snake_walk, self.downgrade) def assertColumnExists(self, engine, table, column): t = get_table(engine, table) self.assertIn(column, t.c) def assertColumnNotExists(self, engine, table, column): t = get_table(engine, table) self.assertNotIn(column, t.c) def assertColumnIsNullable(self, engine, table, column): t = get_table(engine, table) col = getattr(t.c, column) self.assertTrue(col.nullable) def assertIndexExists(self, engine, table, index): t = get_table(engine, table) index_names = [idx.name for idx in t.indexes] self.assertIn(index, index_names) def assertIndexMembers(self, engine, table, index, members): self.assertIndexExists(engine, table, index) t = get_table(engine, table) index_columns = None for idx in t.indexes: if idx.name == index: index_columns = idx.columns.keys() break self.assertEqual(sorted(members), sorted(index_columns)) def _load_mysql_dump_file(self, engine, file_name): for key, eng in self.engines.items(): if eng is engine: conn_string = self.test_databases[key] conn_pieces = urlutils.urlparse(conn_string) if conn_string.startswith('mysql'): break else: return (user, password, database, host) = \ test_migrations.get_db_connection_info(conn_pieces) cmd = ('mysql -u \"%(user)s\" -p\"%(password)s\" -h %(host)s %(db)s ' ) % {'user': user, 'password': password, 'host': host, 'db': database} file_path = os.path.join(os.path.dirname(__file__), file_name) with open(file_path) as sql_file: process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stdin=sql_file, stderr=subprocess.STDOUT) output = process.communicate()[0] self.assertEqual(0, process.returncode, "Failed to run: %s\n%s" % (cmd, output)) def _pre_upgrade_031(self, engine): raw_template = get_table(engine, 'raw_template') templ = [dict(id=3, template='{}')] engine.execute(raw_template.insert(), templ) user_creds = get_table(engine, 'user_creds') user = [dict(id=4, username='angus', password='notthis', tenant='mine', auth_url='bla', tenant_id=str(uuid.uuid4()), trust_id='', trustor_user_id='')] engine.execute(user_creds.insert(), user) stack = get_table(engine, 'stack') stack_ids = ['967aaefb-152e-405d-b13a-35d4c816390c', '9e9deba9-a303-4f29-84d3-c8165647c47e', '9a4bd1ec-8b21-46cd-964a-f66cb1cfa2f9'] data = [dict(id=ll_id, name='fruity', raw_template_id=templ[0]['id'], user_creds_id=user[0]['id'], username='angus', disable_rollback=True) for ll_id in stack_ids] engine.execute(stack.insert(), data) return data def _check_031(self, engine, data): self.assertColumnExists(engine, 'stack_lock', 'stack_id') self.assertColumnExists(engine, 'stack_lock', 'engine_id') self.assertColumnExists(engine, 'stack_lock', 'created_at') self.assertColumnExists(engine, 'stack_lock', 'updated_at') def _check_034(self, engine, data): self.assertColumnExists(engine, 'raw_template', 'files') def _pre_upgrade_035(self, engine): #The stacks id are for the 33 version migration event_table = get_table(engine, 'event') data = [{ 'id': '22222222-152e-405d-b13a-35d4c816390c', 'stack_id': '967aaefb-152e-405d-b13a-35d4c816390c', 'resource_action': 'Test', 'resource_status': 'TEST IN PROGRESS', 'resource_name': 'Testing Resource', 'physical_resource_id': '3465d1ec-8b21-46cd-9dgf-f66cttrh53f9', 'resource_status_reason': '', 'resource_type': '', 'resource_properties': None, 'created_at': datetime.datetime.now()}, {'id': '11111111-152e-405d-b13a-35d4c816390c', 'stack_id': '967aaefb-152e-405d-b13a-35d4c816390c', 'resource_action': 'Test', 'resource_status': 'TEST COMPLETE', 'resource_name': 'Testing Resource', 'physical_resource_id': '3465d1ec-8b21-46cd-9dgf-f66cttrh53f9', 'resource_status_reason': '', 'resource_type': '', 'resource_properties': None, 'created_at': datetime.datetime.now() + datetime.timedelta(days=5)}] engine.execute(event_table.insert(), data) return data def _check_035(self, engine, data): self.assertColumnExists(engine, 'event', 'id') self.assertColumnExists(engine, 'event', 'uuid') event_table = get_table(engine, 'event') events_in_db = list(event_table.select().execute()) last_id = 0 for index, event in enumerate(data): last_id = index + 1 self.assertEqual(last_id, events_in_db[index].id) self.assertEqual(event['id'], events_in_db[index].uuid) #Check that the autoincremental id is ok data = [{ 'uuid': '33333333-152e-405d-b13a-35d4c816390c', 'stack_id': '967aaefb-152e-405d-b13a-35d4c816390c', 'resource_action': 'Test', 'resource_status': 'TEST COMPLEATE AGAIN', 'resource_name': 'Testing Resource', 'physical_resource_id': '3465d1ec-8b21-46cd-9dgf-f66cttrh53f9', 'resource_status_reason': '', 'resource_type': '', 'resource_properties': None, 'created_at': datetime.datetime.now()}] result = engine.execute(event_table.insert(), data) self.assertEqual(last_id + 1, result.inserted_primary_key[0]) def _check_036(self, engine, data): self.assertColumnExists(engine, 'stack', 'stack_user_project_id') def _check_038(self, engine, data): self.assertColumnNotExists(engine, 'software_config', 'io') def _check_039(self, engine, data): self.assertColumnIsNullable(engine, 'stack', 'user_creds_id') def _check_040(self, engine, data): self.assertColumnNotExists(engine, 'software_deployment', 'signal_id') heat-2014.1.5/heat/tests/db/test_migrations.conf0000664000567000056700000000061612540642614022566 0ustar jenkinsjenkins00000000000000[DEFAULT] # Set up any number of databases to test concurrently. # The "name" used in the test is the config variable key. # A few tests rely on one sqlite database with 'sqlite' as the key. sqlite=sqlite:// #sqlitefile=sqlite:///test_migrations_utils.db #mysql=mysql+mysqldb://user:pass@localhost/test_migrations_utils #postgresql=postgresql+psycopg2://user:pass@localhost/test_migrations_utils heat-2014.1.5/heat/tests/test_software_deployment.py0000664000567000056700000004606212540642614023627 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. from heatclient.exc import HTTPNotFound import mock from heat.common import exception from heat.engine import parser from heat.engine.resources.software_config import software_deployment as sd from heat.engine import template from heat.tests.common import HeatTestCase from heat.tests import utils class SoftwareDeploymentTest(HeatTestCase): template = { 'Resources': { 'deployment_mysql': { 'Type': 'OS::Heat::SoftwareDeployment', 'Properties': { 'server': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'config': '48e8ade1-9196-42d5-89a2-f709fde42632', 'input_values': {'foo': 'bar'}, } } } } template_no_signal = { 'Resources': { 'deployment_mysql': { 'Type': 'OS::Heat::SoftwareDeployment', 'Properties': { 'server': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'config': '48e8ade1-9196-42d5-89a2-f709fde42632', 'input_values': {'foo': 'bar', 'bink': 'bonk'}, 'signal_transport': 'NO_SIGNAL', 'name': '00_run_me_first' } } } } template_delete_suspend_resume = { 'Resources': { 'deployment_mysql': { 'Type': 'OS::Heat::SoftwareDeployment', 'Properties': { 'server': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'config': '48e8ade1-9196-42d5-89a2-f709fde42632', 'input_values': {'foo': 'bar'}, 'actions': ['DELETE', 'SUSPEND', 'RESUME'], } } } } def setUp(self): super(SoftwareDeploymentTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() def _create_stack(self, tmpl): self.stack = parser.Stack( self.ctx, 'software_deployment_test_stack', template.Template(tmpl), stack_id='42f6f66b-631a-44e7-8d01-e22fb54574a9', stack_user_project_id='65728b74-cfe7-4f17-9c15-11d4f686e591' ) self.patchobject(sd.SoftwareDeployment, '_create_user') self.patchobject(sd.SoftwareDeployment, '_create_keypair') self.patchobject(sd.SoftwareDeployment, '_delete_user') self.patchobject(sd.SoftwareDeployment, '_delete_signed_url') get_signed_url = self.patchobject( sd.SoftwareDeployment, '_get_signed_url') get_signed_url.return_value = 'http://192.0.2.2/signed_url' self.deployment = self.stack['deployment_mysql'] heat = mock.MagicMock() self.deployment.heat = heat self.deployments = heat.return_value.software_deployments self.software_configs = heat.return_value.software_configs def test_resource_mapping(self): self._create_stack(self.template) self.assertIsInstance(self.deployment, sd.SoftwareDeployment) def mock_software_config(self): sc = mock.MagicMock() sc.to_dict.return_value = { 'id': '48e8ade1-9196-42d5-89a2-f709fde42632', 'group': 'Test::Group', 'name': 'myconfig', 'config': 'the config', 'options': {}, 'inputs': [{ 'name': 'foo', 'type': 'String', 'default': 'baa', }, { 'name': 'bar', 'type': 'String', 'default': 'baz', }], 'outputs': [], } self.software_configs.get.return_value = sc return sc def mock_derived_software_config(self): sc = mock.MagicMock() sc.id = '9966c8e7-bc9c-42de-aa7d-f2447a952cb2' self.software_configs.create.return_value = sc return sc def mock_deployment(self): sd = mock.MagicMock() sd.id = 'c8a19429-7fde-47ea-a42f-40045488226c' self.deployments.create.return_value = sd return sd def test_handle_create(self): self._create_stack(self.template_no_signal) self.mock_software_config() derived_sc = self.mock_derived_software_config() sd = self.mock_deployment() self.deployment.handle_create() self.assertEqual(sd.id, self.deployment.resource_id) self.assertEqual({ 'config': 'the config', 'group': 'Test::Group', 'name': '00_run_me_first', 'inputs': [{ 'default': 'baa', 'name': 'foo', 'type': 'String', 'value': 'bar' }, { 'default': 'baz', 'name': 'bar', 'type': 'String', 'value': 'baz' }, { 'name': 'bink', 'type': 'String', 'value': 'bonk' }, { 'description': 'ID of the server being deployed to', 'name': 'deploy_server_id', 'type': 'String', 'value': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0' }, { 'description': 'Name of the current action being deployed', 'name': 'deploy_action', 'type': 'String', 'value': 'CREATE' }, { 'description': 'ID of the stack this deployment belongs to', 'name': 'deploy_stack_id', 'type': 'String', 'value': ('software_deployment_test_stack' '/42f6f66b-631a-44e7-8d01-e22fb54574a9') }, { 'description': 'Name of this deployment resource in the stack', 'name': 'deploy_resource_name', 'type': 'String', 'value': 'deployment_mysql' }], 'options': {}, 'outputs': [] }, self.software_configs.create.call_args[1]) self.assertEqual( {'action': 'CREATE', 'config_id': derived_sc.id, 'server_id': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'stack_user_project_id': '65728b74-cfe7-4f17-9c15-11d4f686e591', 'status': 'COMPLETE', 'status_reason': 'Not waiting for outputs signal'}, self.deployments.create.call_args[1]) def test_handle_create_do_not_wait(self): self._create_stack(self.template) self.mock_software_config() derived_sc = self.mock_derived_software_config() sd = self.mock_deployment() self.deployment.handle_create() self.assertEqual(sd.id, self.deployment.resource_id) args = self.deployments.create.call_args[1] self.assertEqual( {'action': 'CREATE', 'config_id': derived_sc.id, 'server_id': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'stack_user_project_id': '65728b74-cfe7-4f17-9c15-11d4f686e591', 'status': 'IN_PROGRESS', 'status_reason': 'Deploy data available'}, args) def test_check_create_complete(self): self._create_stack(self.template) sd = mock.MagicMock() sd.status = self.deployment.COMPLETE self.assertTrue(self.deployment.check_create_complete(sd)) sd.status = self.deployment.IN_PROGRESS self.assertFalse(self.deployment.check_create_complete(sd)) def test_check_update_complete(self): self._create_stack(self.template) sd = mock.MagicMock() sd.status = self.deployment.COMPLETE self.assertTrue(self.deployment.check_update_complete(sd)) sd.status = self.deployment.IN_PROGRESS self.assertFalse(self.deployment.check_update_complete(sd)) def test_check_suspend_complete(self): self._create_stack(self.template) sd = mock.MagicMock() sd.status = self.deployment.COMPLETE self.assertTrue(self.deployment.check_suspend_complete(sd)) sd.status = self.deployment.IN_PROGRESS self.assertFalse(self.deployment.check_suspend_complete(sd)) def test_check_resume_complete(self): self._create_stack(self.template) sd = mock.MagicMock() sd.status = self.deployment.COMPLETE self.assertTrue(self.deployment.check_resume_complete(sd)) sd.status = self.deployment.IN_PROGRESS self.assertFalse(self.deployment.check_resume_complete(sd)) def test_check_create_complete_error(self): self._create_stack(self.template) sd = mock.MagicMock() sd.status = self.deployment.FAILED sd.status_reason = 'something wrong' err = self.assertRaises( exception.Error, self.deployment.check_create_complete, sd) self.assertEqual( 'Deployment to server failed: something wrong', str(err)) def test_handle_delete(self): self._create_stack(self.template) sd = self.mock_deployment() self.deployments.get.return_value = sd self.deployment.resource_id = sd.id self.deployment.handle_delete() self.assertEqual([], sd.delete.call_args) def test_delete_complete(self): self._create_stack(self.template_delete_suspend_resume) self.mock_software_config() derived_sc = self.mock_derived_software_config() sd = self.mock_deployment() self.deployment.resource_id = sd.id self.deployments.delete.return_value = None self.deployments.get.return_value = sd sd.update.return_value = None self.assertEqual(sd, self.deployment.handle_delete()) args = sd.update.call_args[1] self.assertEqual({ 'action': 'DELETE', 'config_id': derived_sc.id, 'server_id': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'stack_user_project_id': '65728b74-cfe7-4f17-9c15-11d4f686e591', 'status': 'IN_PROGRESS', 'status_reason': 'Deploy data available' }, args) self.assertFalse(self.deployment.check_delete_complete(sd)) sd.status = self.deployment.COMPLETE self.assertTrue(self.deployment.check_delete_complete(sd)) def test_handle_delete_notfound(self): self._create_stack(self.template) deployment_id = 'c8a19429-7fde-47ea-a42f-40045488226c' self.deployment.resource_id = deployment_id self.mock_software_config() derived_sc = self.mock_derived_software_config() sd = self.mock_deployment() sd.config_id = derived_sc.id self.deployments.get.return_value = sd sd.delete.side_effect = HTTPNotFound() self.software_configs.delete.side_effect = HTTPNotFound() self.assertIsNone(self.deployment.handle_delete()) self.assertEqual( (derived_sc.id,), self.software_configs.delete.call_args[0]) def test_handle_delete_none(self): self._create_stack(self.template) deployment_id = None self.deployment.resource_id = deployment_id self.assertIsNone(self.deployment.handle_delete()) def test_check_delete_complete_none(self): self._create_stack(self.template) self.assertTrue(self.deployment.check_delete_complete()) def test_handle_update(self): self._create_stack(self.template) derived_sc = self.mock_derived_software_config() sd = self.mock_deployment() self.deployments.get.return_value = sd sd.update.return_value = None self.deployment.resource_id = sd.id config_id = '0ff2e903-78d7-4cca-829e-233af3dae705' prop_diff = {'config': config_id} snippet = { 'Properties': { 'server': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'config': config_id, } } self.deployment.handle_update( json_snippet=snippet, tmpl_diff=None, prop_diff=prop_diff) self.assertEqual( (config_id,), self.software_configs.get.call_args[0]) args = self.deployments.get.call_args[0] self.assertEqual(1, len(args)) self.assertIn(sd.id, args) args = sd.update.call_args[1] self.assertEqual(derived_sc.id, args['config_id']) def test_handle_suspend_resume(self): self._create_stack(self.template_delete_suspend_resume) self.mock_software_config() derived_sc = self.mock_derived_software_config() sd = self.mock_deployment() self.deployments.get.return_value = sd sd.update.return_value = None self.deployment.resource_id = sd.id # first, handle the suspend self.deployment.handle_suspend() args = sd.update.call_args[1] self.assertEqual({ 'action': 'SUSPEND', 'config_id': derived_sc.id, 'server_id': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'stack_user_project_id': '65728b74-cfe7-4f17-9c15-11d4f686e591', 'status': 'IN_PROGRESS', 'status_reason': 'Deploy data available' }, args) sd.status = 'IN_PROGRESS' self.assertFalse(self.deployment.check_suspend_complete(sd)) sd.status = 'COMPLETE' self.assertTrue(self.deployment.check_suspend_complete(sd)) # now, handle the resume self.deployment.handle_resume() args = sd.update.call_args[1] self.assertEqual({ 'action': 'RESUME', 'config_id': derived_sc.id, 'server_id': '9f1f0e00-05d2-4ca5-8602-95021f19c9d0', 'stack_user_project_id': '65728b74-cfe7-4f17-9c15-11d4f686e591', 'status': 'IN_PROGRESS', 'status_reason': 'Deploy data available' }, args) sd.status = 'IN_PROGRESS' self.assertFalse(self.deployment.check_resume_complete(sd)) sd.status = 'COMPLETE' self.assertTrue(self.deployment.check_resume_complete(sd)) def test_handle_signal(self): self._create_stack(self.template) sd = mock.MagicMock() sc = mock.MagicMock() sc.outputs = [{'name': 'foo'}, {'name': 'foo2'}, {'name': 'failed', 'error_output': True}] sd.output_values = {} sd.status = self.deployment.IN_PROGRESS sd.update.return_value = None self.deployments.get.return_value = sd self.software_configs.get.return_value = sc details = { 'foo': 'bar', 'deploy_status_code': 0 } self.deployment.handle_signal(details) args = sd.update.call_args[1] self.assertEqual({ 'output_values': { 'foo': 'bar', 'deploy_status_code': 0, 'deploy_stderr': None, 'deploy_stdout': None }, 'status': 'COMPLETE', 'status_reason': 'Outputs received' }, args) def test_handle_signal_failed(self): self._create_stack(self.template) sd = mock.MagicMock() sc = mock.MagicMock() sc.outputs = [{'name': 'foo'}, {'name': 'foo2'}, {'name': 'failed', 'error_output': True}] sd.output_values = {} sd.status = self.deployment.IN_PROGRESS sd.update.return_value = None self.deployments.get.return_value = sd self.software_configs.get.return_value = sc details = {'failed': 'no enough memory found.'} self.deployment.handle_signal(details) args = sd.update.call_args[1] self.assertEqual({ 'output_values': { 'deploy_status_code': None, 'deploy_stderr': None, 'deploy_stdout': None, 'failed': 'no enough memory found.' }, 'status': 'FAILED', 'status_reason': 'failed : no enough memory found.' }, args) def test_handle_status_code_failed(self): self._create_stack(self.template) sd = mock.MagicMock() sd.outputs = [] sd.output_values = {} sd.status = self.deployment.IN_PROGRESS sd.update.return_value = None self.deployments.get.return_value = sd details = { 'deploy_stdout': 'A thing happened', 'deploy_stderr': 'Then it broke', 'deploy_status_code': -1 } self.deployment.handle_signal(details) args = sd.update.call_args[1] self.assertEqual({ 'output_values': { 'deploy_stdout': 'A thing happened', 'deploy_stderr': 'Then it broke', 'deploy_status_code': -1 }, 'status': 'FAILED', 'status_reason': ('deploy_status_code : Deployment exited ' 'with non-zero status code: -1') }, args) def test_handle_signal_not_waiting(self): self._create_stack(self.template) sd = mock.MagicMock() sd.status = self.deployment.COMPLETE self.deployments.get.return_value = sd details = None self.assertIsNone(self.deployment.handle_signal(details)) def test_fn_get_att(self): self._create_stack(self.template) sd = mock.MagicMock() sd.outputs = [{'name': 'failed', 'error_output': True}, {'name': 'foo'}] sd.output_values = { 'foo': 'bar', 'deploy_stdout': 'A thing happened', 'deploy_stderr': 'Extraneous logging', 'deploy_status_code': 0 } self.deployments.get.return_value = sd self.assertEqual('bar', self.deployment.FnGetAtt('foo')) self.assertEqual('A thing happened', self.deployment.FnGetAtt('deploy_stdout')) self.assertEqual('Extraneous logging', self.deployment.FnGetAtt('deploy_stderr')) self.assertEqual(0, self.deployment.FnGetAtt('deploy_status_code')) def test_fn_get_att_error(self): self._create_stack(self.template) sd = mock.MagicMock() sd.outputs = [] sd.output_values = {'foo': 'bar'} err = self.assertRaises( exception.InvalidTemplateAttribute, self.deployment.FnGetAtt, 'foo2') self.assertEqual( 'The Referenced Attribute (deployment_mysql foo2) is incorrect.', str(err)) def test_handle_action(self): self._create_stack(self.template) for action in ('DELETE', 'SUSPEND', 'RESUME'): self.assertIsNone(self.deployment._handle_action(action)) for action in ('CREATE', 'UPDATE'): self.assertIsNotNone(self.deployment._handle_action(action)) heat-2014.1.5/heat/tests/test_watch.py0000664000567000056700000011170212540642614020635 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. import datetime import mox from heat.common import exception import heat.db.api as db_api from heat.engine import parser from heat.engine import watchrule from heat.openstack.common import timeutils from heat.tests.common import HeatTestCase from heat.tests import utils class WatchData(object): def __init__(self, data, created_at): self.created_at = created_at self.data = {'test_metric': {'Value': data, 'Unit': 'Count'}} class DummyAction(object): signal = "DummyAction" class WatchRuleTest(HeatTestCase): stack_id = None @classmethod def setUpDatabase(cls): if cls.stack_id is not None: return # Create a dummy stack in the DB as WatchRule instances # must be associated with a stack utils.setup_dummy_db() ctx = utils.dummy_context() ctx.auth_token = 'abcd1234' empty_tmpl = {"template": {}} tmpl = parser.Template(empty_tmpl) stack_name = 'dummystack' dummy_stack = parser.Stack(ctx, stack_name, tmpl) dummy_stack.state_set(dummy_stack.CREATE, dummy_stack.COMPLETE, 'Testing') dummy_stack.store() cls.stack_id = dummy_stack.id def setUp(self): super(WatchRuleTest, self).setUp() self.setUpDatabase() self.username = 'watchrule_test_user' self.ctx = utils.dummy_context() self.ctx.auth_token = 'abcd1234' self.m.ReplayAll() def _action_set_stubs(self, now, action_expected=True): # Setup stubs for the action tests self.m.StubOutWithMock(timeutils, 'utcnow') timeutils.utcnow().MultipleTimes().AndReturn(now) if action_expected: dummy_action = DummyAction() self.m.StubOutWithMock(parser.Stack, 'resource_by_refid') parser.Stack.resource_by_refid(mox.IgnoreArg()).\ MultipleTimes().AndReturn(dummy_action) self.m.ReplayAll() def test_minimum(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Minimum', 'ComparisonOperator': 'LessThanOrEqualToThreshold', 'Threshold': '50'} now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(77, now - datetime.timedelta(seconds=100))] data.append(WatchData(53, now - datetime.timedelta(seconds=150))) # all > 50 -> NORMAL self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) new_state = self.wr.get_alarm_state() self.assertEqual('NORMAL', new_state) data.append(WatchData(25, now - datetime.timedelta(seconds=250))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) new_state = self.wr.get_alarm_state() self.assertEqual('ALARM', new_state) def test_maximum(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(7, now - datetime.timedelta(seconds=100))] data.append(WatchData(23, now - datetime.timedelta(seconds=150))) # all < 30 -> NORMAL self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('NORMAL', new_state) data.append(WatchData(35, now - datetime.timedelta(seconds=150))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('ALARM', new_state) def test_samplecount(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'SampleCount', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '3'} now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(1, now - datetime.timedelta(seconds=100))] data.append(WatchData(1, now - datetime.timedelta(seconds=150))) # only 2 samples -> NORMAL self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('NORMAL', new_state) # only 3 samples -> ALARM data.append(WatchData(1, now - datetime.timedelta(seconds=200))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('ALARM', new_state) # only 3 samples (one old) -> NORMAL data.pop(0) data.append(WatchData(1, now - datetime.timedelta(seconds=400))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('NORMAL', new_state) def test_sum(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Sum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '100'} now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(17, now - datetime.timedelta(seconds=100))] data.append(WatchData(23, now - datetime.timedelta(seconds=150))) # all < 40 -> NORMAL self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('NORMAL', new_state) # sum > 100 -> ALARM data.append(WatchData(85, now - datetime.timedelta(seconds=150))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('ALARM', new_state) def test_ave(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Average', 'ComparisonOperator': 'GreaterThanThreshold', 'Threshold': '100'} now = timeutils.utcnow() last = now - datetime.timedelta(seconds=320) data = [WatchData(117, now - datetime.timedelta(seconds=100))] data.append(WatchData(23, now - datetime.timedelta(seconds=150))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('NORMAL', new_state) data.append(WatchData(195, now - datetime.timedelta(seconds=250))) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=data, stack_id=self.stack_id, last_evaluated=last) self.wr.now = now new_state = self.wr.get_alarm_state() self.assertEqual('ALARM', new_state) @utils.wr_delete_after def test_load(self): # Insert two dummy watch rules into the DB rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} self.wr = [] self.wr.append(watchrule.WatchRule(context=self.ctx, watch_name='HttpFailureAlarm', rule=rule, watch_data=[], stack_id=self.stack_id, state='NORMAL')) self.wr[0].store() self.wr.append(watchrule.WatchRule(context=self.ctx, watch_name='AnotherWatch', rule=rule, watch_data=[], stack_id=self.stack_id, state='NORMAL')) self.wr[1].store() # Then use WatchRule.load() to retrieve each by name # and check that the object properties match the data above for wn in ('HttpFailureAlarm', 'AnotherWatch'): wr = watchrule.WatchRule.load(self.ctx, wn) self.assertIsInstance(wr, watchrule.WatchRule) self.assertEqual(wn, wr.name) self.assertEqual('NORMAL', wr.state) self.assertEqual(rule, wr.rule) self.assertEqual(datetime.timedelta(seconds=int(rule['Period'])), wr.timeperiod) @utils.wr_delete_after def test_store(self): rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest', stack_id=self.stack_id, rule=rule) self.wr.store() dbwr = db_api.watch_rule_get_by_name(self.ctx, 'storetest') self.assertIsNotNone(dbwr) self.assertEqual('storetest', dbwr.name) self.assertEqual(watchrule.WatchRule.NODATA, dbwr.state) self.assertEqual(rule, dbwr.rule) @utils.wr_delete_after def test_evaluate(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self.m.StubOutWithMock(timeutils, 'utcnow') timeutils.utcnow().MultipleTimes().AndReturn(now) self.m.ReplayAll() # It's not time to evaluate, so should stay NODATA last = now - datetime.timedelta(seconds=299) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NODATA', self.wr.state) self.assertEqual([], actions) # now - last == Period, so should set NORMAL last = now - datetime.timedelta(seconds=300) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NORMAL', self.wr.state) self.assertEqual(now, self.wr.last_evaluated) self.assertEqual([], actions) # Now data breaches Threshold, so should set ALARM last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual(now, self.wr.last_evaluated) self.assertEqual([], actions) @utils.wr_delete_after def test_evaluate_suspend(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self.m.StubOutWithMock(timeutils, 'utcnow') timeutils.utcnow().MultipleTimes().AndReturn(now) self.m.ReplayAll() # Now data breaches Threshold, but we're suspended last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) self.wr.state_set(self.wr.SUSPENDED) actions = self.wr.evaluate() self.assertEqual(self.wr.SUSPENDED, self.wr.state) self.assertEqual([], actions) @utils.wr_delete_after def test_rule_actions_alarm_normal(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self._action_set_stubs(now, action_expected=False) # Set data so rule evaluates to NORMAL state last = now - datetime.timedelta(seconds=300) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NORMAL', self.wr.state) self.assertEqual([], actions) self.m.VerifyAll() @utils.wr_delete_after def test_rule_actions_alarm_alarm(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self._action_set_stubs(now) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual(['DummyAction'], actions) # re-set last_evaluated so the rule will be evaluated again. last = now - datetime.timedelta(seconds=300) self.wr.last_evaluated = last actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual(['DummyAction'], actions) self.m.VerifyAll() @utils.wr_delete_after def test_rule_actions_alarm_two_actions(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction', 'AnotherDummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self._action_set_stubs(now) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual(['DummyAction', 'DummyAction'], actions) self.m.VerifyAll() @utils.wr_delete_after def test_rule_actions_ok_alarm(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'OKActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self._action_set_stubs(now, action_expected=False) # On creation the rule evaluates to NODATA state last = now - datetime.timedelta(seconds=300) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NODATA', self.wr.state) self.assertEqual([], actions) # Move time forward and add data below threshold so we transition from # ALARM -> NORMAL, so evaluate() should output a 'DummyAction' now = now + datetime.timedelta(seconds=300) self.m.VerifyAll() self.m.UnsetStubs() self._action_set_stubs(now) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr.watch_data = [data] actions = self.wr.evaluate() self.assertEqual('NORMAL', self.wr.state) self.assertEqual(['DummyAction'], actions) self.m.VerifyAll() @utils.wr_delete_after def test_rule_actions_nodata(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'InsufficientDataActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self._action_set_stubs(now, action_expected=False) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual([], actions) # Move time forward and don't add data so we transition from # ALARM -> NODATA, so evaluate() should output a 'DummyAction' now = now + datetime.timedelta(seconds=300) self.m.VerifyAll() self.m.UnsetStubs() self._action_set_stubs(now) actions = self.wr.evaluate() self.assertEqual('NODATA', self.wr.state) self.assertEqual(['DummyAction'], actions) self.m.VerifyAll() @utils.wr_delete_after def test_create_watch_data(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) self.wr.store() data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": []}} self.wr.create_watch_data(data) dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test') self.assertEqual(data, dbwr.watch_data[0].data) # Note, would be good to write another datapoint and check it # but sqlite seems to not interpret the backreference correctly # so dbwr.watch_data is always a list containing only the latest # datapoint. In non-test use on mysql this is not the case, we # correctly get a list of all datapoints where watch_rule_id == # watch_rule.id, so leave it as a single-datapoint test for now. @utils.wr_delete_after def test_create_watch_data_suspended(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule, state=watchrule.WatchRule.SUSPENDED) self.wr.store() data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": []}} self.wr.create_watch_data(data) dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test') self.assertEqual([], dbwr.watch_data) @utils.wr_delete_after def test_create_watch_data_match(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) self.wr.store() data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [{u'AutoScalingGroupName': u'group_x'}]}} self.assertTrue(watchrule.rule_can_use_sample(self.wr, data)) @utils.wr_delete_after def test_create_watch_data_match_2(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) self.wr.store() data = {u'not_interesting': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}, u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}} self.assertTrue(watchrule.rule_can_use_sample(self.wr, data)) def test_create_watch_data_match_3(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) self.wr.store() data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'not_this'}]}, u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}} self.assertTrue(watchrule.rule_can_use_sample(self.wr, data)) def test_create_watch_data_not_match_metric(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) self.wr.store() data = {u'not_this': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}, u'nor_this': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'group_x'}]}} self.assertFalse(watchrule.rule_can_use_sample(self.wr, data)) def test_create_watch_data_not_match_dimensions(self): rule = {u'EvaluationPeriods': u'1', u'AlarmDescription': u'test alarm', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'Dimensions': [{u'Name': 'AutoScalingGroupName', u'Value': 'group_x'}], u'MetricName': u'CreateDataMetric'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) self.wr.store() data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'AutoScalingGroupName': u'not_this'}]}, u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": [ {u'wrong_key': u'group_x'}]}} self.assertFalse(watchrule.rule_can_use_sample(self.wr, data)) def test_destroy(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} last = timeutils.utcnow() self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch_destroy", rule=rule, watch_data=[], stack_id=self.stack_id, last_evaluated=last) self.wr.store() check = watchrule.WatchRule.load(context=self.ctx, watch_name="testwatch_destroy") self.assertIsInstance(check, watchrule.WatchRule) self.wr.destroy() self.assertRaises(exception.WatchRuleNotFound, watchrule.WatchRule.load, context=self.ctx, watch_name="testwatch_destroy") def test_state_set(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} last = timeutils.utcnow() watcher = watchrule.WatchRule(context=self.ctx, watch_name="testwatch_set_state", rule=rule, watch_data=[], stack_id=self.stack_id, last_evaluated=last) watcher.state_set(watcher.SUSPENDED) self.assertEqual(watcher.SUSPENDED, watcher.state) check = watchrule.WatchRule.load(context=self.ctx, watch_name="testwatch_set_state") self.assertEqual(watchrule.WatchRule.SUSPENDED, check.state) def test_set_watch_state(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() self._action_set_stubs(now) # Set data so rule evaluates to ALARM state last = now - datetime.timedelta(seconds=200) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.set_watch_state(watchrule.WatchRule.NODATA) self.assertEqual([], actions) actions = self.wr.set_watch_state(watchrule.WatchRule.NORMAL) self.assertEqual([], actions) actions = self.wr.set_watch_state(watchrule.WatchRule.ALARM) self.assertEqual(['DummyAction'], actions) self.m.VerifyAll() def test_set_watch_state_invalid(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'AlarmActions': ['DummyAction'], 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() last = now - datetime.timedelta(seconds=200) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[], stack_id=self.stack_id, last_evaluated=last) self.assertRaises(ValueError, self.wr.set_watch_state, None) self.assertRaises(ValueError, self.wr.set_watch_state, "BADSTATE") heat-2014.1.5/heat/tests/test_eip.py0000664000567000056700000004572212540642614020314 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. import mox from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import parser from heat.engine import resource from heat.engine.resources import eip from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import fakes as fakec from heat.tests import utils from heat.tests.v1_1 import fakes eip_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "EIP Test", "Parameters" : {}, "Resources" : { "IPAddress" : { "Type" : "AWS::EC2::EIP", "Properties" : { "InstanceId" : { "Ref" : "WebServer" } } }, "WebServer": { "Type": "AWS::EC2::Instance", } } } ''' eip_template_ipassoc = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "EIP Test", "Parameters" : {}, "Resources" : { "IPAddress" : { "Type" : "AWS::EC2::EIP" }, "IPAssoc" : { "Type" : "AWS::EC2::EIPAssociation", "Properties" : { "InstanceId" : { "Ref" : "WebServer" }, "EIP" : { "Ref" : "IPAddress" } } }, "WebServer": { "Type": "AWS::EC2::Instance", } } } ''' eip_template_ipassoc2 = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "EIP Test", "Parameters" : {}, "Resources" : { "the_eip" : { "Type" : "AWS::EC2::EIP", "Properties" : { "Domain": "vpc" } }, "IPAssoc" : { "Type" : "AWS::EC2::EIPAssociation", "Properties" : { "AllocationId" : 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', "NetworkInterfaceId" : { "Ref" : "the_nic" } } }, "the_vpc" : { "Type" : "AWS::EC2::VPC", "Properties" : { "CidrBlock" : "10.0.0.0/16" } }, "the_subnet" : { "Type" : "AWS::EC2::Subnet", "Properties" : { "CidrBlock" : "10.0.0.0/24", "VpcId" : { "Ref" : "the_vpc" } } }, "the_nic" : { "Type" : "AWS::EC2::NetworkInterface", "Properties" : { "PrivateIpAddress": "10.0.0.100", "SubnetId": { "Ref": "the_subnet" } } }, } } ''' eip_template_ipassoc3 = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "EIP Test", "Parameters" : {}, "Resources" : { "the_eip" : { "Type" : "AWS::EC2::EIP", "Properties" : { "Domain": "vpc" } }, "IPAssoc" : { "Type" : "AWS::EC2::EIPAssociation", "Properties" : { "AllocationId" : 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', "InstanceId" : '1fafbe59-2332-4f5f-bfa4-517b4d6c1b65' } } } } ''' def force_networking(mode): if mode == 'nova': force_networking.client = clients.neutronclient clients.neutronclient = None if mode == 'neutron': clients.neutronclient = force_networking.client force_networking.client = None class EIPTest(HeatTestCase): def setUp(self): # force Nova, will test Neutron below force_networking('nova') super(EIPTest, self).setUp() self.fc = fakes.FakeClient() self.m.StubOutWithMock(eip.ElasticIp, 'nova') self.m.StubOutWithMock(eip.ElasticIpAssociation, 'nova') self.m.StubOutWithMock(self.fc.servers, 'get') utils.setup_dummy_db() def tearDown(self): super(EIPTest, self).tearDown() force_networking('neutron') def create_eip(self, t, stack, resource_name): rsrc = eip.ElasticIp(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_association(self, t, stack, resource_name): rsrc = eip.ElasticIpAssociation(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_eip(self): eip.ElasticIp.nova().MultipleTimes().AndReturn(self.fc) self.fc.servers.get('WebServer').AndReturn(self.fc.servers.list()[0]) self.fc.servers.get('WebServer') self.m.ReplayAll() t = template_format.parse(eip_template) stack = utils.parse_stack(t) rsrc = self.create_eip(t, stack, 'IPAddress') try: self.assertEqual('11.0.0.1', rsrc.FnGetRefId()) rsrc.refid = None self.assertEqual('11.0.0.1', rsrc.FnGetRefId()) self.assertEqual('1', rsrc.FnGetAtt('AllocationId')) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') finally: scheduler.TaskRunner(rsrc.destroy)() self.m.VerifyAll() def test_association_eip(self): eip.ElasticIp.nova().MultipleTimes().AndReturn(self.fc) eip.ElasticIpAssociation.nova().MultipleTimes().AndReturn(self.fc) self.fc.servers.get('WebServer').MultipleTimes() \ .AndReturn(self.fc.servers.list()[0]) self.m.ReplayAll() t = template_format.parse(eip_template_ipassoc) stack = utils.parse_stack(t) rsrc = self.create_eip(t, stack, 'IPAddress') association = self.create_association(t, stack, 'IPAssoc') try: self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual((association.CREATE, association.COMPLETE), association.state) self.assertEqual(utils.PhysName(stack.name, association.name), association.FnGetRefId()) self.assertEqual('11.0.0.1', association.properties['EIP']) finally: scheduler.TaskRunner(association.delete)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.assertEqual((association.DELETE, association.COMPLETE), association.state) self.m.VerifyAll() def test_eip_with_exception(self): self.m.StubOutWithMock(self.fc.floating_ips, 'create') eip.ElasticIp.nova().MultipleTimes().AndReturn(self.fc) self.fc.floating_ips.create().AndRaise( clients.novaclient.exceptions.NotFound('fake_falure')) self.m.ReplayAll() t = template_format.parse(eip_template) stack = utils.parse_stack(t) resource_name = 'IPAddress' rsrc = eip.ElasticIp(resource_name, t['Resources'][resource_name], stack) self.assertRaises(clients.novaclient.exceptions.NotFound, rsrc.handle_create) self.m.VerifyAll() def test_delete_eip_with_exception(self): self.m.StubOutWithMock(self.fc.floating_ips, 'delete') eip.ElasticIp.nova().MultipleTimes().AndReturn(self.fc) self.fc.floating_ips.delete(mox.IsA(object)).AndRaise( clients.novaclient.exceptions.NotFound('fake_falure')) self.fc.servers.get(mox.IsA(object)).AndReturn(False) self.m.ReplayAll() t = template_format.parse(eip_template) stack = utils.parse_stack(t) resource_name = 'IPAddress' rsrc = eip.ElasticIp(resource_name, t['Resources'][resource_name], stack) rsrc.resource_id = 'fake_id' rsrc.handle_delete() self.m.VerifyAll() class AllocTest(HeatTestCase): @skipIf(clients.neutronclient is None, 'neutronclient unavailable') def setUp(self): super(AllocTest, self).setUp() self.fc = fakes.FakeClient() self.m.StubOutWithMock(eip.ElasticIp, 'nova') self.m.StubOutWithMock(eip.ElasticIpAssociation, 'nova') self.m.StubOutWithMock(self.fc.servers, 'get') self.m.StubOutWithMock(parser.Stack, 'resource_by_refid') self.m.StubOutWithMock(clients.neutronclient.Client, 'create_floatingip') self.m.StubOutWithMock(clients.neutronclient.Client, 'show_floatingip') self.m.StubOutWithMock(clients.neutronclient.Client, 'update_floatingip') self.m.StubOutWithMock(clients.neutronclient.Client, 'delete_floatingip') self.m.StubOutWithMock(clients.neutronclient.Client, 'add_gateway_router') self.m.StubOutWithMock(clients.neutronclient.Client, 'list_networks') self.m.StubOutWithMock(clients.neutronclient.Client, 'list_ports') self.m.StubOutWithMock(clients.neutronclient.Client, 'list_subnets') self.m.StubOutWithMock(clients.neutronclient.Client, 'show_network') self.m.StubOutWithMock(clients.neutronclient.Client, 'list_routers') self.m.StubOutWithMock(clients.neutronclient.Client, 'remove_gateway_router') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def mock_show_network(self): vpc_name = utils.PhysName('test_stack', 'the_vpc') clients.neutronclient.Client.show_network( 'aaaa-netid' ).AndReturn({"network": { "status": "BUILD", "subnets": [], "name": vpc_name, "admin_state_up": False, "shared": False, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "aaaa-netid" }}) def create_eip(self, t, stack, resource_name): rsrc = eip.ElasticIp(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_association(self, t, stack, resource_name): rsrc = eip.ElasticIpAssociation(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def mock_update_floatingip(self, port='the_nic'): clients.neutronclient.Client.update_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {'floatingip': {'port_id': port}}).AndReturn(None) def mock_create_gateway_attachment(self): clients.neutronclient.Client.add_gateway_router( 'bbbb', {'network_id': 'eeee'}).AndReturn(None) def mock_create_floatingip(self): clients.neutronclient.Client.list_networks( **{'router:external': True}).AndReturn({'networks': [{ 'status': 'ACTIVE', 'subnets': [], 'name': 'nova', 'router:external': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'admin_state_up': True, 'shared': True, 'id': 'eeee' }]}) clients.neutronclient.Client.create_floatingip({ 'floatingip': {'floating_network_id': u'eeee'} }).AndReturn({'floatingip': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "floating_ip_address": "192.168.9.3" }}) def mock_show_floatingip(self, refid): clients.neutronclient.Client.show_floatingip( refid, ).AndReturn({'floatingip': { 'router_id': None, 'tenant_id': 'e936e6cd3e0b48dcb9ff853a8f253257', 'floating_network_id': 'eeee', 'fixed_ip_address': None, 'floating_ip_address': '172.24.4.227', 'port_id': None, 'id': 'ffff' }}) def mock_delete_floatingip(self): id = 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' clients.neutronclient.Client.delete_floatingip(id).AndReturn(None) def mock_list_ports(self): clients.neutronclient.Client.list_ports(id='the_nic').AndReturn( {"ports": [{ "status": "DOWN", "binding:host_id": "null", "name": "wp-NIC-yu7fc7l4g5p6", "admin_state_up": True, "network_id": "22c26451-cf27-4d48-9031-51f5e397b84e", "tenant_id": "ecf538ec1729478fa1f97f1bf4fdcf7b", "binding:vif_type": "ovs", "device_owner": "", "binding:capabilities": {"port_filter": True}, "mac_address": "fa:16:3e:62:2d:4f", "fixed_ips": [{"subnet_id": "mysubnetid-70ec", "ip_address": "192.168.9.2"}], "id": "a000228d-b40b-4124-8394-a4082ae1b76b", "security_groups": ["5c6f529d-3186-4c36-84c0-af28b8daac7b"], "device_id": "" }]}) def mock_list_instance_ports(self, refid): clients.neutronclient.Client.list_ports(device_id=refid).AndReturn( {"ports": [{ "status": "DOWN", "binding:host_id": "null", "name": "wp-NIC-yu7fc7l4g5p6", "admin_state_up": True, "network_id": "22c26451-cf27-4d48-9031-51f5e397b84e", "tenant_id": "ecf538ec1729478fa1f97f1bf4fdcf7b", "binding:vif_type": "ovs", "device_owner": "", "binding:capabilities": {"port_filter": True}, "mac_address": "fa:16:3e:62:2d:4f", "fixed_ips": [{"subnet_id": "mysubnetid-70ec", "ip_address": "192.168.9.2"}], "id": "a000228d-b40b-4124-8394-a4082ae1b76c", "security_groups": ["5c6f529d-3186-4c36-84c0-af28b8daac7b"], "device_id": refid }]}) def mock_list_subnets(self): clients.neutronclient.Client.list_subnets( id='mysubnetid-70ec').AndReturn( {'subnets': [{ u'name': u'wp-Subnet-pyjm7bvoi4xw', u'enable_dhcp': True, u'network_id': u'aaaa-netid', u'tenant_id': u'ecf538ec1729478fa1f97f1bf4fdcf7b', u'dns_nameservers': [], u'allocation_pools': [{u'start': u'192.168.9.2', u'end': u'192.168.9.254'}], u'host_routes': [], u'ip_version': 4, u'gateway_ip': u'192.168.9.1', u'cidr': u'192.168.9.0/24', u'id': u'2c339ccd-734a-4acc-9f64-6f0dfe427e2d' }]}) def mock_router_for_vpc(self): vpc_name = utils.PhysName('test_stack', 'the_vpc') clients.neutronclient.Client.list_routers(name=vpc_name).AndReturn({ "routers": [{ "status": "ACTIVE", "external_gateway_info": { "network_id": "zzzz", "enable_snat": True}, "name": vpc_name, "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "bbbb" }] }) def mock_no_router_for_vpc(self): vpc_name = utils.PhysName('test_stack', 'the_vpc') clients.neutronclient.Client.list_routers(name=vpc_name).AndReturn({ "routers": [] }) def mock_keystone(self): clients.OpenStackClients.keystone().AndReturn( fakec.FakeKeystoneClient()) def test_neutron_eip(self): eip.ElasticIp.nova().MultipleTimes().AndReturn(self.fc) self.fc.servers.get('WebServer').AndReturn(self.fc.servers.list()[0]) self.fc.servers.get('WebServer') self.m.ReplayAll() t = template_format.parse(eip_template) stack = utils.parse_stack(t) rsrc = self.create_eip(t, stack, 'IPAddress') try: self.assertEqual('11.0.0.1', rsrc.FnGetRefId()) rsrc.refid = None self.assertEqual('11.0.0.1', rsrc.FnGetRefId()) self.assertEqual('1', rsrc.FnGetAtt('AllocationId')) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') finally: scheduler.TaskRunner(rsrc.destroy)() self.m.VerifyAll() def test_association_allocationid(self): self.mock_keystone() self.mock_create_gateway_attachment() self.mock_show_network() self.mock_router_for_vpc() self.mock_create_floatingip() self.mock_list_ports() self.mock_list_subnets() self.mock_show_floatingip('fc68ea2c-b60b-4b4f-bd82-94ec81110766') self.mock_update_floatingip() self.mock_update_floatingip(port=None) self.mock_delete_floatingip() self.m.ReplayAll() t = template_format.parse(eip_template_ipassoc2) stack = utils.parse_stack(t) rsrc = self.create_eip(t, stack, 'the_eip') association = self.create_association(t, stack, 'IPAssoc') scheduler.TaskRunner(association.delete)() scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_association_allocationid_with_instance(self): self.mock_keystone() self.mock_show_network() self.mock_create_floatingip() self.mock_list_instance_ports('1fafbe59-2332-4f5f-bfa4-517b4d6c1b65') self.mock_list_subnets() self.mock_no_router_for_vpc() self.mock_update_floatingip( port='a000228d-b40b-4124-8394-a4082ae1b76c') self.mock_update_floatingip(port=None) self.mock_delete_floatingip() self.m.ReplayAll() t = template_format.parse(eip_template_ipassoc3) stack = utils.parse_stack(t) rsrc = self.create_eip(t, stack, 'the_eip') association = self.create_association(t, stack, 'IPAssoc') scheduler.TaskRunner(association.delete)() scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_multi_part.py0000664000567000056700000001452212540642614021711 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. import email import mock from heat.engine import parser from heat.engine import template import heat.engine.resources.software_config.multi_part as mp from heat.tests.common import HeatTestCase from heat.tests import utils import heatclient.exc as exc class MultipartMimeTest(HeatTestCase): def setUp(self): super(MultipartMimeTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() self.init_config() def init_config(self, parts=[]): stack = parser.Stack( self.ctx, 'software_config_test_stack', template.Template({ 'Resources': { 'config_mysql': { 'Type': 'OS::Heat::MultipartMime', 'Properties': { 'parts': parts }}}})) self.config = stack['config_mysql'] heat = mock.MagicMock() self.config.heat = heat self.software_configs = heat.return_value.software_configs def test_resource_mapping(self): mapping = mp.resource_mapping() self.assertEqual(1, len(mapping)) self.assertEqual(mp.MultipartMime, mapping['OS::Heat::MultipartMime']) self.assertIsInstance(self.config, mp.MultipartMime) def test_handle_create(self): sc = mock.MagicMock() config_id = 'c8a19429-7fde-47ea-a42f-40045488226c' sc.id = config_id self.software_configs.create.return_value = sc self.config.handle_create() self.assertEqual(config_id, self.config.resource_id) args = self.software_configs.create.call_args[1] self.assertEqual(self.config.message, args['config']) def test_get_message_not_none(self): self.config.message = 'Not none' result = self.config.get_message() self.assertEqual('Not none', result) def test_get_message_empty_list(self): parts = [] self.init_config(parts=parts) result = self.config.get_message() message = email.message_from_string(result) self.assertTrue(message.is_multipart()) def test_get_message_text(self): parts = [{ 'config': '1e0e5a60-2843-4cfd-9137-d90bdf18eef5', 'type': 'text' }] self.init_config(parts=parts) self.software_configs.get.return_value.config = '#!/bin/bash' result = self.config.get_message() message = email.message_from_string(result) self.assertTrue(message.is_multipart()) subs = message.get_payload() self.assertEqual(1, len(subs)) self.assertEqual('#!/bin/bash', subs[0].get_payload()) def test_get_message_fail_back(self): parts = [{ 'config': '#!/bin/bash', 'type': 'text' }] self.init_config(parts=parts) self.software_configs.get.side_effect = exc.HTTPNotFound() result = self.config.get_message() message = email.message_from_string(result) self.assertTrue(message.is_multipart()) subs = message.get_payload() self.assertEqual(1, len(subs)) self.assertEqual('#!/bin/bash', subs[0].get_payload()) def test_get_message_text_with_filename(self): parts = [{ 'config': '1e0e5a60-2843-4cfd-9137-d90bdf18eef5', 'type': 'text', 'filename': '/opt/stack/configure.d/55-heat-config' }] self.init_config(parts=parts) self.software_configs.get.return_value.config = '#!/bin/bash' result = self.config.get_message() message = email.message_from_string(result) self.assertTrue(message.is_multipart()) subs = message.get_payload() self.assertEqual(1, len(subs)) self.assertEqual('#!/bin/bash', subs[0].get_payload()) self.assertEqual(parts[0]['filename'], subs[0].get_filename()) def test_get_message_multi_part(self): multipart = ('Content-Type: multipart/mixed; ' 'boundary="===============2579792489038011818=="\n' 'MIME-Version: 1.0\n' '\n--===============2579792489038011818==' '\nContent-Type: text; ' 'charset="us-ascii"\n' 'MIME-Version: 1.0\n' 'Content-Transfer-Encoding: 7bit\n' 'Content-Disposition: attachment;\n' ' filename="/opt/stack/configure.d/55-heat-config"\n' '#!/bin/bash\n' '--===============2579792489038011818==--\n') parts = [{ 'config': '1e0e5a60-2843-4cfd-9137-d90bdf18eef5', 'type': 'multipart' }] self.init_config(parts=parts) self.software_configs.get.return_value.config = multipart result = self.config.get_message() message = email.message_from_string(result) self.assertTrue(message.is_multipart()) subs = message.get_payload() self.assertEqual(1, len(subs)) self.assertEqual('#!/bin/bash', subs[0].get_payload()) self.assertEqual('/opt/stack/configure.d/55-heat-config', subs[0].get_filename()) def test_get_message_multi_part_bad_format(self): parts = [ {'config': '1e0e5a60-2843-4cfd-9137-d90bdf18eef5', 'type': 'multipart'}, {'config': '9cab10ef-16ce-4be9-8b25-a67b7313eddb', 'type': 'text'}] self.init_config(parts=parts) self.software_configs.get.return_value.config = '#!/bin/bash' result = self.config.get_message() message = email.message_from_string(result) self.assertTrue(message.is_multipart()) subs = message.get_payload() self.assertEqual(1, len(subs)) self.assertEqual('#!/bin/bash', subs[0].get_payload()) heat-2014.1.5/heat/tests/test_engine_api_utils.py0000664000567000056700000007316312540642614023055 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. from datetime import datetime import json import uuid import mock from heat.common.identifier import EventIdentifier from heat.common import template_format from heat.engine import api from heat.engine.event import Event from heat.engine import parameters from heat.engine import parser from heat.engine import resource from heat.rpc import api as rpc_api from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import utils class EngineApiTest(HeatTestCase): def test_timeout_extract(self): p = {'timeout_mins': '5'} args = api.extract_args(p) self.assertEqual(5, args['timeout_mins']) def test_timeout_extract_zero(self): p = {'timeout_mins': '0'} args = api.extract_args(p) self.assertNotIn('timeout_mins', args) def test_timeout_extract_garbage(self): p = {'timeout_mins': 'wibble'} args = api.extract_args(p) self.assertNotIn('timeout_mins', args) def test_timeout_extract_none(self): p = {'timeout_mins': None} args = api.extract_args(p) self.assertNotIn('timeout_mins', args) def test_timeout_extract_negative(self): p = {'timeout_mins': '-100'} error = self.assertRaises(ValueError, api.extract_args, p) self.assertIn('Invalid timeout value', str(error)) def test_timeout_extract_not_present(self): args = api.extract_args({}) self.assertNotIn('timeout_mins', args) def test_adopt_stack_data_extract_present(self): p = {'adopt_stack_data': json.dumps({'Resources': {}})} args = api.extract_args(p) self.assertTrue(args.get('adopt_stack_data')) def test_invalid_adopt_stack_data(self): p = {'adopt_stack_data': json.dumps("foo")} error = self.assertRaises(ValueError, api.extract_args, p) self.assertEqual( 'Unexpected adopt data "foo". Adopt data must be a dict.', str(error)) def test_adopt_stack_data_extract_not_present(self): args = api.extract_args({}) self.assertNotIn('adopt_stack_data', args) def test_disable_rollback_extract_true(self): args = api.extract_args({'disable_rollback': True}) self.assertIn('disable_rollback', args) self.assertTrue(args.get('disable_rollback')) args = api.extract_args({'disable_rollback': 'True'}) self.assertIn('disable_rollback', args) self.assertTrue(args.get('disable_rollback')) args = api.extract_args({'disable_rollback': 'true'}) self.assertIn('disable_rollback', args) self.assertTrue(args.get('disable_rollback')) def test_disable_rollback_extract_false(self): args = api.extract_args({'disable_rollback': False}) self.assertIn('disable_rollback', args) self.assertFalse(args.get('disable_rollback')) args = api.extract_args({'disable_rollback': 'False'}) self.assertIn('disable_rollback', args) self.assertFalse(args.get('disable_rollback')) args = api.extract_args({'disable_rollback': 'false'}) self.assertIn('disable_rollback', args) self.assertFalse(args.get('disable_rollback')) def test_disable_rollback_extract_bad(self): self.assertRaises(ValueError, api.extract_args, {'disable_rollback': 'bad'}) class FormatTest(HeatTestCase): def setUp(self): super(FormatTest, self).setUp() utils.setup_dummy_db() template = parser.Template({ 'Resources': { 'generic1': {'Type': 'GenericResourceType'}, 'generic2': { 'Type': 'GenericResourceType', 'DependsOn': 'generic1'} } }) resource._register_class('GenericResourceType', generic_rsrc.GenericResource) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', template, stack_id=str(uuid.uuid4())) def _dummy_event(self, event_id): resource = self.stack['generic1'] return Event(utils.dummy_context(), self.stack, 'CREATE', 'COMPLETE', 'state changed', 'z3455xyc-9f88-404d-a85b-5315293e67de', resource.properties, resource.name, resource.type(), uuid='abc123yc-9f88-404d-a85b-531529456xyz', id=event_id) def test_format_stack_resource(self): res = self.stack['generic1'] resource_keys = set(( rpc_api.RES_UPDATED_TIME, rpc_api.RES_NAME, rpc_api.RES_PHYSICAL_ID, rpc_api.RES_METADATA, rpc_api.RES_ACTION, rpc_api.RES_STATUS, rpc_api.RES_STATUS_DATA, rpc_api.RES_TYPE, rpc_api.RES_ID, rpc_api.RES_STACK_ID, rpc_api.RES_STACK_NAME, rpc_api.RES_REQUIRED_BY)) resource_details_keys = resource_keys.union(set( (rpc_api.RES_DESCRIPTION, rpc_api.RES_METADATA))) formatted = api.format_stack_resource(res, True) self.assertEqual(resource_details_keys, set(formatted.keys())) formatted = api.format_stack_resource(res, False) self.assertEqual(resource_keys, set(formatted.keys())) def test_format_stack_resource_required_by(self): res1 = api.format_stack_resource(self.stack['generic1']) res2 = api.format_stack_resource(self.stack['generic2']) self.assertEqual(['generic2'], res1['required_by']) self.assertEqual([], res2['required_by']) def test_format_event_identifier_uuid(self): self._test_format_event('abc123yc-9f88-404d-a85b-531529456xyz') def _test_format_event(self, event_id): event = self._dummy_event(event_id) event_keys = set(( rpc_api.EVENT_ID, rpc_api.EVENT_STACK_ID, rpc_api.EVENT_STACK_NAME, rpc_api.EVENT_TIMESTAMP, rpc_api.EVENT_RES_NAME, rpc_api.EVENT_RES_PHYSICAL_ID, rpc_api.EVENT_RES_ACTION, rpc_api.EVENT_RES_STATUS, rpc_api.EVENT_RES_STATUS_DATA, rpc_api.EVENT_RES_TYPE, rpc_api.EVENT_RES_PROPERTIES)) formatted = api.format_event(event) self.assertEqual(event_keys, set(formatted.keys())) event_id_formatted = formatted[rpc_api.EVENT_ID] event_identifier = EventIdentifier(event_id_formatted['tenant'], event_id_formatted['stack_name'], event_id_formatted['stack_id'], event_id_formatted['path']) self.assertEqual(event_id, event_identifier.event_id) @mock.patch.object(api, 'format_stack_resource') def test_format_stack_preview(self, mock_fmt_resource): def mock_format_resources(res): return 'fmt%s' % res mock_fmt_resource.side_effect = mock_format_resources resources = [1, [2, [3]]] self.stack.preview_resources = mock.Mock(return_value=resources) stack = api.format_stack_preview(self.stack) self.assertIsInstance(stack, dict) self.assertEqual('test_stack', stack['stack_name']) self.assertIn('resources', stack) self.assertEqual(['fmt1', ['fmt2', ['fmt3']]], stack['resources']) def test_format_stack(self): self.stack.created_time = datetime(1970, 1, 1) info = api.format_stack(self.stack) aws_id = ('arn:openstack:heat::test_tenant_id:' 'stacks/test_stack/' + self.stack.id) expected_stack_info = { 'capabilities': [], 'creation_time': '1970-01-01T00:00:00Z', 'description': 'No description', 'disable_rollback': True, 'notification_topics': [], 'stack_action': '', 'stack_name': 'test_stack', 'stack_status': '', 'stack_status_reason': '', 'template_description': 'No description', 'timeout_mins': None, 'parameters': { 'AWS::Region': 'ap-southeast-1', 'AWS::StackId': aws_id, 'AWS::StackName': 'test_stack'}, 'stack_identity': { 'path': '', 'stack_id': self.stack.id, 'stack_name': 'test_stack', 'tenant': 'test_tenant_id'}, 'updated_time': None} self.assertEqual(expected_stack_info, info) def test_format_stack_created_time(self): self.stack.created_time = None info = api.format_stack(self.stack) self.assertIsNotNone(info['creation_time']) def test_format_stack_updated_time(self): self.stack.updated_time = None info = api.format_stack(self.stack) self.assertIsNone(info['updated_time']) self.stack.updated_time = datetime(1970, 1, 1) info = api.format_stack(self.stack) self.assertEqual('1970-01-01T00:00:00Z', info['updated_time']) @mock.patch.object(api, 'format_stack_outputs') def test_format_stack_adds_outputs(self, mock_fmt_outputs): mock_fmt_outputs.return_value = 'foobar' self.stack.action = 'CREATE' self.stack.status = 'COMPLETE' info = api.format_stack(self.stack) self.assertEqual('foobar', info[rpc_api.STACK_OUTPUTS]) class FormatValidateParameterTest(HeatTestCase): base_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test", "Parameters" : { %s } } ''' base_template_hot = ''' { "heat_template_version" : "2013-05-23", "description" : "test", "parameters" : { %s } } ''' scenarios = [ ('simple', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair" } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('default', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "Default": "dummy" } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'Default': 'dummy', 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('min_length_constraint', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "MinLength": 4 } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('max_length_constraint', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "MaxLength": 10 } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MaxLength': 10, 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('min_max_length_constraint', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "MinLength": 4, "MaxLength": 10 } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'MaxLength': 10, 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('min_value_constraint', dict(template=base_template, param_name='MyNumber', param=''' "MyNumber": { "Type": "Number", "Description": "A number", "MinValue": 4 } ''', expected={ 'Type': 'Number', 'Description': 'A number', 'MinValue': 4, 'NoEcho': 'false', 'Label': 'MyNumber' }) ), ('max_value_constraint', dict(template=base_template, param_name='MyNumber', param=''' "MyNumber": { "Type": "Number", "Description": "A number", "MaxValue": 10 } ''', expected={ 'Type': 'Number', 'Description': 'A number', 'MaxValue': 10, 'NoEcho': 'false', 'Label': 'MyNumber' }) ), ('min_max_value_constraint', dict(template=base_template, param_name='MyNumber', param=''' "MyNumber": { "Type": "Number", "Description": "A number", "MinValue": 4, "MaxValue": 10 } ''', expected={ 'Type': 'Number', 'Description': 'A number', 'MinValue': 4, 'MaxValue': 10, 'NoEcho': 'false', 'Label': 'MyNumber' }) ), ('allowed_values_constraint', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "AllowedValues": [ "foo", "bar", "blub" ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'AllowedValues': ['foo', 'bar', 'blub'], 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('allowed_pattern_constraint', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "AllowedPattern": "[a-zA-Z0-9]+" } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'AllowedPattern': "[a-zA-Z0-9]+", 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('multiple_constraints', dict(template=base_template, param_name='KeyName', param=''' "KeyName": { "Type": "String", "Description": "Name of SSH key pair", "MinLength": 4, "MaxLength": 10, "AllowedValues": [ "foo", "bar", "blub" ], "AllowedPattern": "[a-zA-Z0-9]+" } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'MaxLength': 10, 'AllowedValues': ['foo', 'bar', 'blub'], 'AllowedPattern': "[a-zA-Z0-9]+", 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('simple_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair" } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('default_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "default": "dummy" } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'Default': 'dummy', 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('min_length_constraint_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "length": { "min": 4} } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('max_length_constraint_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "length": { "max": 10} } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MaxLength': 10, 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('min_max_length_constraint_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "length": { "min":4, "max": 10} } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'MaxLength': 10, 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('min_value_constraint_hot', dict(template=base_template_hot, param_name='MyNumber', param=''' "MyNumber": { "type": "number", "description": "A number", "constraints": [ { "range": { "min": 4} } ] } ''', expected={ 'Type': 'Number', 'Description': 'A number', 'MinValue': 4, 'NoEcho': 'false', 'Label': 'MyNumber' }) ), ('max_value_constraint_hot', dict(template=base_template_hot, param_name='MyNumber', param=''' "MyNumber": { "type": "number", "description": "A number", "constraints": [ { "range": { "max": 10} } ] } ''', expected={ 'Type': 'Number', 'Description': 'A number', 'MaxValue': 10, 'NoEcho': 'false', 'Label': 'MyNumber' }) ), ('min_max_value_constraint_hot', dict(template=base_template_hot, param_name='MyNumber', param=''' "MyNumber": { "type": "number", "description": "A number", "constraints": [ { "range": { "min": 4, "max": 10} } ] } ''', expected={ 'Type': 'Number', 'Description': 'A number', 'MinValue': 4, 'MaxValue': 10, 'NoEcho': 'false', 'Label': 'MyNumber' }) ), ('allowed_values_constraint_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "allowed_values": [ "foo", "bar", "blub" ] } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'AllowedValues': ['foo', 'bar', 'blub'], 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('allowed_pattern_constraint_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "allowed_pattern": "[a-zA-Z0-9]+" } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'AllowedPattern': "[a-zA-Z0-9]+", 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('multiple_constraints_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "length": { "min": 4, "max": 10} }, { "allowed_values": [ "foo", "bar", "blub" ] }, { "allowed_pattern": "[a-zA-Z0-9]+" } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'MaxLength': 10, 'AllowedValues': ['foo', 'bar', 'blub'], 'AllowedPattern': "[a-zA-Z0-9]+", 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('constraint_description_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "length": { "min": 4}, "description": "Big enough" } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'ConstraintDescription': 'Big enough', 'NoEcho': 'false', 'Label': 'KeyName' }) ), ('constraint_multiple_descriptions_hot', dict(template=base_template_hot, param_name='KeyName', param=''' "KeyName": { "type": "string", "description": "Name of SSH key pair", "constraints": [ { "length": { "min": 4}, "description": "Big enough." }, { "allowed_pattern": "[a-zA-Z0-9]+", "description": "Only letters." } ] } ''', expected={ 'Type': 'String', 'Description': 'Name of SSH key pair', 'MinLength': 4, 'AllowedPattern': "[a-zA-Z0-9]+", 'ConstraintDescription': 'Big enough. Only letters.', 'NoEcho': 'false', 'Label': 'KeyName' }) ), ] def test_format_validate_parameter(self): """ Test format of a parameter. """ t = template_format.parse(self.template % self.param) tmpl = parser.Template(t) tmpl_params = parameters.Parameters(None, tmpl) tmpl_params.validate(validate_value=False) param = tmpl_params.params[self.param_name] param_formated = api.format_validate_parameter(param) self.assertEqual(self.expected, param_formated) class FormatSoftwareConfigDeploymentTest(HeatTestCase): def _dummy_software_config(self): config = mock.Mock() config.name = 'config_mysql' config.group = 'Heat::Shell' config.id = str(uuid.uuid4()) config.config = { 'inputs': [{'name': 'bar'}], 'outputs': [{'name': 'result'}], 'options': {}, 'config': '#!/bin/bash\n' } return config def _dummy_software_deployment(self): config = self._dummy_software_config() deployment = mock.Mock() deployment.config = config deployment.id = str(uuid.uuid4()) deployment.server_id = str(uuid.uuid4()) deployment.input_values = {'bar': 'baaaaa'} deployment.output_values = {'result': '0'} deployment.action = 'INIT' deployment.status = 'COMPLETE' deployment.status_reason = 'Because' return deployment def test_format_software_config(self): config = self._dummy_software_config() result = api.format_software_config(config) self.assertIsNotNone(result) self.assertEqual([{'name': 'bar'}], result['inputs']) self.assertEqual([{'name': 'result'}], result['outputs']) self.assertEqual({}, result['options']) def test_format_software_config_none(self): self.assertIsNone(api.format_software_config(None)) def test_format_software_deployment(self): deployment = self._dummy_software_deployment() result = api.format_software_deployment(deployment) self.assertIsNotNone(result) self.assertEqual(deployment.id, result['id']) self.assertEqual(deployment.config.id, result['config_id']) self.assertEqual(deployment.server_id, result['server_id']) self.assertEqual(deployment.input_values, result['input_values']) self.assertEqual(deployment.output_values, result['output_values']) self.assertEqual(deployment.action, result['action']) self.assertEqual(deployment.status, result['status']) self.assertEqual(deployment.status_reason, result['status_reason']) def test_format_software_deployment_none(self): self.assertIsNone(api.format_software_deployment(None)) heat-2014.1.5/heat/tests/test_instance.py0000664000567000056700000010553712540642614021344 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. import copy import uuid import mox from neutronclient.v2_0 import client as neutronclient from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.engine.resources import image from heat.engine.resources import instance as instances from heat.engine.resources import network_interface from heat.engine.resources import nova_utils from heat.engine import scheduler from heat.openstack.common import uuidutils from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes wp_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "wordpress" } } } } ''' class InstancesTest(HeatTestCase): def setUp(self): super(InstancesTest, self).setUp() self.fc = fakes.FakeClient() utils.setup_dummy_db() def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) return (t, stack) def _setup_test_instance(self, return_server, name, image_id=None, stub_create=True): stack_name = '%s_s' % name (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['ImageId'] = \ image_id or 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance(name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) if stub_create: self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=utils.PhysName( stack_name, instance.name, limit=instance.physical_resource_name_limit), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( return_server) return instance def _create_test_instance(self, return_server, name, stub_create=True): instance = self._setup_test_instance(return_server, name, stub_create=stub_create) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() return instance def test_instance_create(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_create') # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() def test_instance_create_with_image_id(self): return_server = self.fc.servers.list()[1] instance = self._setup_test_instance(return_server, 'in_create_imgid', image_id='1') self.m.StubOutWithMock(uuidutils, "is_uuid_like") uuidutils.is_uuid_like('1').MultipleTimes().AndReturn(True) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PublicDnsName')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() def test_instance_create_image_name_err(self): stack_name = 'test_instance_create_image_name_err_stack' (t, stack) = self._setup_test_stack(stack_name) # create an instance with non exist image name t['Resources']['WebServer']['Properties']['ImageId'] = 'Slackware' instance = instances.Instance('instance_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertRaises(ValueError, instance.handle_create) self.m.VerifyAll() def test_instance_create_duplicate_image_name_err(self): stack_name = 'test_instance_create_image_name_err_stack' (t, stack) = self._setup_test_stack(stack_name) # create an instance with a non unique image name t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' instance = instances.Instance('instance_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc.client, "get_images_detail") self.fc.client.get_images_detail().AndReturn(( 200, {'images': [{'id': 1, 'name': 'CentOS 5.2'}, {'id': 4, 'name': 'CentOS 5.2'}]})) self.m.ReplayAll() self.assertRaises(ValueError, instance.handle_create) self.m.VerifyAll() def test_instance_create_image_id_err(self): stack_name = 'test_instance_create_image_id_err_stack' (t, stack) = self._setup_test_stack(stack_name) # create an instance with non exist image Id t['Resources']['WebServer']['Properties']['ImageId'] = '1' instance = instances.Instance('instance_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(uuidutils, "is_uuid_like") uuidutils.is_uuid_like('1').AndReturn(True) self.m.StubOutWithMock(self.fc.client, "get_images_1") self.fc.client.get_images_1().AndRaise( instances.clients.novaclient.exceptions.NotFound(404)) self.m.ReplayAll() self.assertRaises(ValueError, instance.handle_create) self.m.VerifyAll() class FakeVolumeAttach: def started(self): return False def test_instance_create_unexpected_status(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'test_instance_create') return_server.get = lambda: None return_server.status = 'BOGUS' self.assertRaises(exception.Error, instance.check_create_complete, (return_server, self.FakeVolumeAttach())) def test_instance_create_error_status(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'test_instance_create') return_server.status = 'ERROR' return_server.fault = { 'message': 'NoValidHost', 'code': 500, 'created': '2013-08-14T03:12:10Z' } self.m.StubOutWithMock(return_server, 'get') return_server.get() self.m.ReplayAll() self.assertRaises(exception.Error, instance.check_create_complete, (return_server, self.FakeVolumeAttach())) self.m.VerifyAll() def test_instance_create_error_no_fault(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_create') return_server.status = 'ERROR' self.m.StubOutWithMock(return_server, 'get') return_server.get() self.m.ReplayAll() e = self.assertRaises( exception.Error, instance.check_create_complete, (return_server, self.FakeVolumeAttach())) self.assertEqual( 'Creation of server sample-server2 failed: Unknown (500)', str(e)) self.m.VerifyAll() def test_instance_validate(self): stack_name = 'test_instance_validate_stack' (t, stack) = self._setup_test_stack(stack_name) # create an instance with non exist image Id t['Resources']['WebServer']['Properties']['ImageId'] = '1' instance = instances.Instance('instance_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(uuidutils, "is_uuid_like") uuidutils.is_uuid_like('1').MultipleTimes().AndReturn(True) self.m.ReplayAll() self.assertIsNone(instance.validate()) self.m.VerifyAll() def test_instance_create_delete(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_cr_del') instance.resource_id = 1234 # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(instances.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) scheduler.TaskRunner(instance.delete)() self.assertIsNone(instance.resource_id) self.assertEqual((instance.DELETE, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_update_metadata(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'ud_md') update_template = copy.deepcopy(instance.t) update_template['Metadata'] = {'test': 123} scheduler.TaskRunner(instance.update, update_template)() self.assertEqual({'test': 123}, instance.metadata) def test_instance_update_instance_type(self): """ Instance.handle_update supports changing the InstanceType, and makes the change making a resize API call against Nova. """ return_server = self.fc.servers.list()[1] return_server.id = 1234 instance = self._create_test_instance(return_server, 'ud_type') update_template = copy.deepcopy(instance.t) update_template['Properties']['InstanceType'] = 'm1.small' self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(1234).AndReturn(return_server) def activate_status(server): server.status = 'VERIFY_RESIZE' return_server.get = activate_status.__get__(return_server) self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') self.fc.client.post_servers_1234_action( body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) self.fc.client.post_servers_1234_action( body={'confirmResize': None}).AndReturn((202, None)) self.m.ReplayAll() scheduler.TaskRunner(instance.update, update_template)() self.assertEqual((instance.UPDATE, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_update_instance_type_failed(self): """ If the status after a resize is not VERIFY_RESIZE, it means the resize call failed, so we raise an explicit error. """ return_server = self.fc.servers.list()[1] return_server.id = 1234 instance = self._create_test_instance(return_server, 'ud_type_f') update_template = copy.deepcopy(instance.t) update_template['Properties']['InstanceType'] = 'm1.small' self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(1234).AndReturn(return_server) def activate_status(server): server.status = 'ACTIVE' return_server.get = activate_status.__get__(return_server) self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') self.fc.client.post_servers_1234_action( body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) self.m.ReplayAll() updater = scheduler.TaskRunner(instance.update, update_template) error = self.assertRaises(exception.ResourceFailure, updater) self.assertEqual( "Error: Resizing to 'm1.small' failed, status 'ACTIVE'", str(error)) self.assertEqual((instance.UPDATE, instance.FAILED), instance.state) self.m.VerifyAll() def test_instance_update_replace(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_update1') update_template = copy.deepcopy(instance.t) update_template['Notallowed'] = {'test': 123} updater = scheduler.TaskRunner(instance.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def test_instance_update_properties(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_update2') self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() update_template = copy.deepcopy(instance.t) update_template['Properties']['ImageId'] = 'mustreplace' updater = scheduler.TaskRunner(instance.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def test_instance_status_build(self): return_server = self.fc.servers.list()[0] instance = self._setup_test_instance(return_server, 'in_sts_build') instance.resource_id = 1234 # Bind fake get method which Instance.check_create_complete will call def activate_status(server): server.status = 'ACTIVE' return_server.get = activate_status.__get__(return_server) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) def test_instance_status_suspend_immediate(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_suspend') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d['server']['status'] = 'SUSPENDED' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d)) mox.Replay(get) scheduler.TaskRunner(instance.suspend)() self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_status_resume_immediate(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_resume') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d['server']['status'] = 'ACTIVE' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d)) mox.Replay(get) instance.state_set(instance.SUSPEND, instance.COMPLETE) scheduler.TaskRunner(instance.resume)() self.assertEqual((instance.RESUME, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_status_suspend_wait(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_suspend_wait') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED, but # return the ACTIVE state first (twice, so we sleep) d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d2 = copy.deepcopy(d1) d1['server']['status'] = 'ACTIVE' d2['server']['status'] = 'SUSPENDED' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d1)) get().AndReturn((200, d1)) get().AndReturn((200, d2)) self.m.ReplayAll() scheduler.TaskRunner(instance.suspend)() self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_status_resume_wait(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_resume_wait') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to ACTIVE, but # return the SUSPENDED state first (twice, so we sleep) d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d2 = copy.deepcopy(d1) d1['server']['status'] = 'SUSPENDED' d2['server']['status'] = 'ACTIVE' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d1)) get().AndReturn((200, d1)) get().AndReturn((200, d2)) self.m.ReplayAll() instance.state_set(instance.SUSPEND, instance.COMPLETE) scheduler.TaskRunner(instance.resume)() self.assertEqual((instance.RESUME, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_suspend_volumes_step(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_suspend_vol') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d['server']['status'] = 'SUSPENDED' # Return a dummy PollingTaskGroup to make check_suspend_complete step def dummy_detach(): yield dummy_tg = scheduler.PollingTaskGroup([dummy_detach, dummy_detach]) self.m.StubOutWithMock(instance, '_detach_volumes_task') instance._detach_volumes_task().AndReturn(dummy_tg) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d)) self.m.ReplayAll() scheduler.TaskRunner(instance.suspend)() self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_resume_volumes_step(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_resume_vol') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to ACTIVE d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d['server']['status'] = 'ACTIVE' # Return a dummy PollingTaskGroup to make check_resume_complete step def dummy_attach(): yield dummy_tg = scheduler.PollingTaskGroup([dummy_attach, dummy_attach]) self.m.StubOutWithMock(instance, '_attach_volumes_task') instance._attach_volumes_task().AndReturn(dummy_tg) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d)) self.m.ReplayAll() instance.state_set(instance.SUSPEND, instance.COMPLETE) scheduler.TaskRunner(instance.resume)() self.assertEqual((instance.RESUME, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_suspend_volumes_wait(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_suspend_vol') instance.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED, but keep # it ACTIVE for the first two iterations of check_suspend_complete. d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d2 = copy.deepcopy(d1) d1['server']['status'] = 'ACTIVE' d2['server']['status'] = 'SUSPENDED' # Return a dummy PollingTaskGroup to make check_suspend_complete step def dummy_detach(): yield dummy_tg = scheduler.PollingTaskGroup([dummy_detach, dummy_detach]) self.m.StubOutWithMock(instance, '_detach_volumes_task') instance._detach_volumes_task().AndReturn(dummy_tg) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d1)) get().AndReturn((200, d1)) get().AndReturn((200, d2)) self.m.ReplayAll() scheduler.TaskRunner(instance.suspend)() self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_status_build_spawning(self): self._test_instance_status_not_build_active('BUILD(SPAWNING)') def test_instance_status_hard_reboot(self): self._test_instance_status_not_build_active('HARD_REBOOT') def test_instance_status_password(self): self._test_instance_status_not_build_active('PASSWORD') def test_instance_status_reboot(self): self._test_instance_status_not_build_active('REBOOT') def test_instance_status_rescue(self): self._test_instance_status_not_build_active('RESCUE') def test_instance_status_resize(self): self._test_instance_status_not_build_active('RESIZE') def test_instance_status_revert_resize(self): self._test_instance_status_not_build_active('REVERT_RESIZE') def test_instance_status_shutoff(self): self._test_instance_status_not_build_active('SHUTOFF') def test_instance_status_suspended(self): self._test_instance_status_not_build_active('SUSPENDED') def test_instance_status_verify_resize(self): self._test_instance_status_not_build_active('VERIFY_RESIZE') def _test_instance_status_not_build_active(self, uncommon_status): return_server = self.fc.servers.list()[0] instance = self._setup_test_instance(return_server, 'in_sts_bld') instance.resource_id = 1234 # Bind fake get method which Instance.check_create_complete will call def activate_status(server): if hasattr(server, '_test_check_iterations'): server._test_check_iterations += 1 else: server._test_check_iterations = 1 if server._test_check_iterations == 1: server.status = uncommon_status if server._test_check_iterations > 2: server.status = 'ACTIVE' return_server.get = activate_status.__get__(return_server) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_build_nics(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'build_nics') self.assertIsNone(instance._build_nics([])) self.assertIsNone(instance._build_nics(None)) self.assertEqual([ {'port-id': 'id3'}, {'port-id': 'id1'}, {'port-id': 'id2'}], instance._build_nics([ 'id3', 'id1', 'id2'])) self.assertEqual( [{'port-id': 'id1'}, {'port-id': 'id2'}, {'port-id': 'id3'}], instance._build_nics([ {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'}, {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'}, {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2}, ])) self.assertEqual( [{'port-id': 'id1'}, {'port-id': 'id2'}, {'port-id': 'id3'}, {'port-id': 'id4'}, {'port-id': 'id5'}], instance._build_nics([ {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'}, {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'}, {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2}, 'id4', 'id5'] )) def test_build_nics_with_security_groups(self): """ Test the security groups defined in heat template can be associated to a new created port. """ return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'build_nics2') security_groups = ['security_group_1'] self._test_security_groups(instance, security_groups) security_groups = ['0389f747-7785-4757-b7bb-2ab07e4b09c3'] self._test_security_groups(instance, security_groups, all_uuids=True) security_groups = ['0389f747-7785-4757-b7bb-2ab07e4b09c3', '384ccd91-447c-4d83-832c-06974a7d3d05'] self._test_security_groups(instance, security_groups, sg='two', all_uuids=True) security_groups = ['security_group_1', '384ccd91-447c-4d83-832c-06974a7d3d05'] self._test_security_groups(instance, security_groups, sg='two') security_groups = ['wrong_group_name'] self._test_security_groups( instance, security_groups, sg='zero', get_secgroup_raises=exception.PhysicalResourceNotFound) security_groups = ['wrong_group_name', '0389f747-7785-4757-b7bb-2ab07e4b09c3'] self._test_security_groups( instance, security_groups, get_secgroup_raises=exception.PhysicalResourceNotFound) security_groups = ['wrong_group_name', 'security_group_1'] self._test_security_groups( instance, security_groups, get_secgroup_raises=exception.PhysicalResourceNotFound) security_groups = ['duplicate_group_name', 'security_group_1'] self._test_security_groups( instance, security_groups, get_secgroup_raises=exception.PhysicalResourceNameAmbiguity) def _test_security_groups(self, instance, security_groups, sg='one', all_uuids=False, get_secgroup_raises=None): fake_groups_list, props = self._get_fake_properties(sg) nclient = neutronclient.Client() self.m.StubOutWithMock(instance, 'neutron') instance.neutron().MultipleTimes().AndReturn(nclient) if not all_uuids: # list_security_groups only gets called when none of the requested # groups look like UUIDs. self.m.StubOutWithMock( neutronclient.Client, 'list_security_groups') neutronclient.Client.list_security_groups().AndReturn( fake_groups_list) net_interface = network_interface.NetworkInterface self.m.StubOutWithMock(net_interface, 'network_id_from_subnet_id') net_interface.network_id_from_subnet_id( nclient, 'fake_subnet_id').MultipleTimes().AndReturn('fake_network_id') if not get_secgroup_raises: self.m.StubOutWithMock(neutronclient.Client, 'create_port') neutronclient.Client.create_port( {'port': props}).MultipleTimes().AndReturn( {'port': {'id': 'fake_port_id'}}) self.m.ReplayAll() if get_secgroup_raises: self.assertRaises(get_secgroup_raises, instance._build_nics, None, security_groups=security_groups, subnet_id='fake_subnet_id') else: self.assertEqual( [{'port-id': 'fake_port_id'}], instance._build_nics(None, security_groups=security_groups, subnet_id='fake_subnet_id')) self.m.VerifyAll() self.m.UnsetStubs() def _get_fake_properties(self, sg='one'): fake_groups_list = { 'security_groups': [ { 'id': '0389f747-7785-4757-b7bb-2ab07e4b09c3', 'name': 'security_group_1', 'security_group_rules': [], 'description': 'no protocol' }, { 'id': '384ccd91-447c-4d83-832c-06974a7d3d05', 'name': 'security_group_2', 'security_group_rules': [], 'description': 'no protocol' }, { 'id': 'e91a0007-06a6-4a4a-8edb-1d91315eb0ef', 'name': 'duplicate_group_name', 'security_group_rules': [], 'description': 'no protocol' }, { 'id': '8be37f3c-176d-4826-aa17-77d1d9df7b2e', 'name': 'duplicate_group_name', 'security_group_rules': [], 'description': 'no protocol' } ] } fixed_ip = {'subnet_id': 'fake_subnet_id'} props = { 'admin_state_up': True, 'network_id': 'fake_network_id', 'fixed_ips': [fixed_ip], 'security_groups': ['0389f747-7785-4757-b7bb-2ab07e4b09c3'] } if sg == 'zero': props['security_groups'] = [] elif sg == 'one': props['security_groups'] = ['0389f747-7785-4757-b7bb-2ab07e4b09c3'] elif sg == 'two': props['security_groups'] = ['0389f747-7785-4757-b7bb-2ab07e4b09c3', '384ccd91-447c-4d83-832c-06974a7d3d05'] return fake_groups_list, props def test_instance_without_ip_address(self): return_server = self.fc.servers.list()[3] instance = self._create_test_instance(return_server, 'wo_ipaddr') self.assertEqual('0.0.0.0', instance.FnGetAtt('PrivateIp')) def test_default_instance_user(self): """The default value for instance_user in heat.conf is ec2-user.""" return_server = self.fc.servers.list()[1] instance = self._setup_test_instance(return_server, 'default_user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(instance, 'wordpress', 'ec2-user') self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.m.VerifyAll() def test_custom_instance_user(self): """Test instance_user in heat.conf being set to a custom value. Launching the instance should call build_userdata with the custom user name. This option is deprecated and will be removed in Juno. """ return_server = self.fc.servers.list()[1] instance = self._setup_test_instance(return_server, 'custom_user') self.m.StubOutWithMock(instances.cfg.CONF, 'instance_user') instances.cfg.CONF.instance_user = 'custom_user' self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(instance, 'wordpress', 'custom_user') self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.m.VerifyAll() def test_empty_instance_user(self): """Test instance_user in heat.conf being empty. Launching the instance should call build_userdata with "ec2-user". This behaviour is compatible with CloudFormation and will be the default in Juno once the instance_user option gets removed. """ return_server = self.fc.servers.list()[1] instance = self._setup_test_instance(return_server, 'empty_user') self.m.StubOutWithMock(instances.cfg.CONF, 'instance_user') instances.cfg.CONF.instance_user = '' self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(instance, 'wordpress', 'ec2-user') self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_random_string.py0000664000567000056700000000744712540642614022407 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. from testtools.matchers import HasLength from testtools.matchers import MatchesRegex from heat.common import exception from heat.common import template_format from heat.engine import parser from heat.engine.resources.random_string import RandomString from heat.tests.common import HeatTestCase from heat.tests import utils class TestRandomString(HeatTestCase): template_random_string = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: secret1: Type: OS::Heat::RandomString secret2: Type: OS::Heat::RandomString Properties: length: 10 secret3: Type: OS::Heat::RandomString Properties: length: 100 sequence: octdigits ''' def setUp(self): super(HeatTestCase, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() def create_stack(self, template): t = template_format.parse(template) self.stack = self.parse_stack(t) self.assertIsNone(self.stack.create()) return self.stack def parse_stack(self, t): stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, tmpl) stack.validate() stack.store() return stack def test_random_string(self): stack = self.create_stack(self.template_random_string) secret1 = stack['secret1'] random_string = secret1.FnGetAtt('value') self.assertThat(random_string, MatchesRegex('[a-zA-Z0-9]{32}')) self.assertRaises(exception.InvalidTemplateAttribute, secret1.FnGetAtt, 'foo') self.assertEqual(random_string, secret1.FnGetRefId()) secret2 = stack['secret2'] random_string = secret2.FnGetAtt('value') self.assertThat(random_string, MatchesRegex('[a-zA-Z0-9]{10}')) self.assertEqual(random_string, secret2.FnGetRefId()) secret3 = stack['secret3'] random_string = secret3.FnGetAtt('value') self.assertThat(random_string, MatchesRegex('[0-7]{100}')) self.assertEqual(random_string, secret3.FnGetRefId()) class TestGenerateRandomString(HeatTestCase): scenarios = [ ('lettersdigits', dict( length=1, seq='lettersdigits', pattern='[a-zA-Z0-9]')), ('letters', dict( length=10, seq='letters', pattern='[a-zA-Z]')), ('lowercase', dict( length=100, seq='lowercase', pattern='[a-z]')), ('uppercase', dict( length=50, seq='uppercase', pattern='[A-Z]')), ('digits', dict( length=512, seq='digits', pattern='[0-9]')), ('hexdigits', dict( length=16, seq='hexdigits', pattern='[A-F0-9]')), ('octdigits', dict( length=32, seq='octdigits', pattern='[0-7]')) ] def test_generate_random_string(self): # run each test multiple times to confirm random generator # doesn't generate a matching pattern by chance for i in range(1, 32): sequence = RandomString._sequences[self.seq] r = RandomString._generate_random_string(sequence, self.length) self.assertThat(r, HasLength(self.length)) regex = '%s{%s}' % (self.pattern, self.length) self.assertThat(r, MatchesRegex(regex)) heat-2014.1.5/heat/tests/test_nova_floatingip.py0000664000567000056700000001505112540642614022706 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. from novaclient import exceptions as ncli_ex from novaclient.v1_1 import client as novaclient from heat.common import exception as heat_ex from heat.common import template_format from heat.engine import clients from heat.engine.resources.nova_floatingip import NovaFloatingIp from heat.engine.resources.nova_floatingip import NovaFloatingIpAssociation from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils floating_ip_template = ''' { "heat_template_version": "2013-05-23", "Resources": { "MyFloatingIP": { "Type": "OS::Nova::FloatingIP", "Properties": { "pool": "public" } } } } ''' floating_ip_template_with_assoc = ''' { "heat_template_version": "2013-05-23", "Resources": { "MyFloatingIPAssociation": { "Type": "OS::Nova::FloatingIPAssociation", "Properties": { "server_id": "67dc62f9-efde-4c8b-94af-013e00f5dc57", "floating_ip": "1" } } } } ''' class NovaFloatingIPTest(HeatTestCase): def setUp(self): super(NovaFloatingIPTest, self).setUp() self.novaclient = novaclient.Client('user', 'pass', 'project', 'uri') self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(self.novaclient.floating_ips, 'create') self.m.StubOutWithMock(self.novaclient.floating_ips, 'get') self.m.StubOutWithMock(self.novaclient.floating_ips, 'delete') self.m.StubOutWithMock(self.novaclient.servers, 'get') self.m.StubOutWithMock(self.novaclient.servers, 'add_floating_ip') self.m.StubOutWithMock(self.novaclient.servers, 'remove_floating_ip') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def _make_obj(self, **kwargs): mock = self.m.CreateMockAnything() for k, v in kwargs.iteritems(): setattr(mock, k, v) return mock def prepare_floating_ip(self): clients.OpenStackClients.nova('compute').AndReturn(self.novaclient) self.novaclient.floating_ips.create(pool='public').AndReturn( self._make_obj(**{ 'id': '1', 'ip': '11.0.0.1', 'pool': 'public' }) ) template = template_format.parse(floating_ip_template) stack = utils.parse_stack(template) floating_ip = template['Resources']['MyFloatingIP'] return NovaFloatingIp('MyFloatingIP', floating_ip, stack) def prepare_floating_ip_assoc(self): clients.OpenStackClients.nova('compute').MultipleTimes().AndReturn( self.novaclient) self.novaclient.servers.get('67dc62f9-efde-4c8b-94af-013e00f5dc57') self.novaclient.floating_ips.get('1').AndReturn( self._make_obj(**{ 'id': '1', 'ip': '11.0.0.1', 'pool': 'public' }) ) template = template_format.parse(floating_ip_template_with_assoc) stack = utils.parse_stack(template) floating_ip_assoc = template['Resources']['MyFloatingIPAssociation'] return NovaFloatingIpAssociation('MyFloatingIPAssociation', floating_ip_assoc, stack) def test_floating_ip_create(self): rsrc = self.prepare_floating_ip() self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('1', rsrc.FnGetRefId()) self.assertEqual('11.0.0.1', rsrc.FnGetAtt('ip')) self.assertEqual('public', rsrc.FnGetAtt('pool')) self.m.VerifyAll() def test_floating_ip_delete(self): rsrc = self.prepare_floating_ip() rsrc.validate() clients.OpenStackClients.nova('compute').AndReturn(self.novaclient) self.novaclient.floating_ips.delete('1') self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_floating_ip_assoc_successful_if_create_failed(self): rsrc = self.prepare_floating_ip_assoc() self.novaclient.servers.add_floating_ip(None, '11.0.0.1').AndRaise( ncli_ex.BadRequest(400)) self.m.ReplayAll() rsrc.validate() self.assertRaises(heat_ex.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_floating_ip_assoc_create(self): rsrc = self.prepare_floating_ip_assoc() self.novaclient.servers.add_floating_ip(None, '11.0.0.1') self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_floating_ip_assoc_delete(self): rsrc = self.prepare_floating_ip_assoc() self.novaclient.servers.add_floating_ip(None, '11.0.0.1') self.novaclient.servers.get( '67dc62f9-efde-4c8b-94af-013e00f5dc57').AndReturn('server') self.novaclient.floating_ips.get('1').AndReturn( self._make_obj(**{ 'id': '1', 'ip': '11.0.0.1', 'pool': 'public' }) ) self.novaclient.servers.remove_floating_ip('server', '11.0.0.1') self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_function.py0000664000567000056700000000516112540642614021355 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. import copy from heat.tests.common import HeatTestCase from heat.engine import function class TestFunction(function.Function): def result(self): return 'wibble' class FunctionTest(HeatTestCase): def test_equal(self): func = TestFunction(None, 'foo', ['bar', 'baz']) self.assertTrue(func == 'wibble') self.assertTrue('wibble' == func) def test_not_equal(self): func = TestFunction(None, 'foo', ['bar', 'baz']) self.assertTrue(func != 'foo') self.assertTrue('foo' != func) def test_equal_func(self): func1 = TestFunction(None, 'foo', ['bar', 'baz']) func2 = TestFunction(None, 'blarg', ['wibble', 'quux']) self.assertTrue(func1 == func2) def test_copy(self): func = TestFunction(None, 'foo', ['bar', 'baz']) self.assertEqual({'foo': ['bar', 'baz']}, copy.deepcopy(func)) class ResolveTest(HeatTestCase): def test_resolve_func(self): func = TestFunction(None, 'foo', ['bar', 'baz']) result = function.resolve(func) self.assertEqual('wibble', result) self.assertTrue(isinstance(result, str)) def test_resolve_dict(self): func = TestFunction(None, 'foo', ['bar', 'baz']) snippet = {'foo': 'bar', 'blarg': func} result = function.resolve(snippet) self.assertEqual({'foo': 'bar', 'blarg': 'wibble'}, result) self.assertIsNot(result, snippet) def test_resolve_list(self): func = TestFunction(None, 'foo', ['bar', 'baz']) snippet = ['foo', 'bar', 'baz', 'blarg', func] result = function.resolve(snippet) self.assertEqual(['foo', 'bar', 'baz', 'blarg', 'wibble'], result) self.assertIsNot(result, snippet) def test_resolve_all(self): func = TestFunction(None, 'foo', ['bar', 'baz']) snippet = ['foo', {'bar': ['baz', {'blarg': func}]}] result = function.resolve(snippet) self.assertEqual(['foo', {'bar': ['baz', {'blarg': 'wibble'}]}], result) self.assertIsNot(result, snippet) heat-2014.1.5/heat/tests/test_user.py0000664000567000056700000004005012540642614020502 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. import uuid from oslo.config import cfg from heat.common import exception from heat.common import short_id from heat.common import template_format from heat.db import api as db_api from heat.engine import resource from heat.engine.resources import user from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils user_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a User", "Parameters" : {}, "Resources" : { "CfnUser" : { "Type" : "AWS::IAM::User" } } } ''' user_template_password = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a User", "Parameters" : {}, "Resources" : { "CfnUser" : { "Type" : "AWS::IAM::User", "Properties": { "LoginProfile": { "Password": "myP@ssW0rd" } } } } } ''' user_accesskey_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a User", "Parameters" : {}, "Resources" : { "CfnUser" : { "Type" : "AWS::IAM::User" }, "HostKeys" : { "Type" : "AWS::IAM::AccessKey", "Properties" : { "UserName" : {"Ref": "CfnUser"} } } } } ''' user_policy_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a User", "Parameters" : {}, "Resources" : { "CfnUser" : { "Type" : "AWS::IAM::User", "Properties" : { "Policies" : [ { "Ref": "WebServerAccessPolicy"} ] } }, "WebServerAccessPolicy" : { "Type" : "OS::Heat::AccessPolicy", "Properties" : { "AllowedResources" : [ "WikiDatabase" ] } }, "WikiDatabase" : { "Type" : "AWS::EC2::Instance", } } } ''' class UserTest(HeatTestCase): def setUp(self): super(UserTest, self).setUp() self.username = 'test_stack-CfnUser-aabbcc' self.fc = fakes.FakeKeystoneClient(username=self.username) cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role') utils.setup_dummy_db() self.resource_id = str(uuid.uuid4()) def create_user(self, t, stack, resource_name, project_id='stackproject', user_id='dummy_user', password=None): self.m.StubOutWithMock(user.User, 'keystone') user.User.keystone().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'create_stack_domain_project') fakes.FakeKeystoneClient.create_stack_domain_project( stack.id).AndReturn(project_id) self.m.StubOutWithMock(short_id, 'get_id') short_id.get_id(self.resource_id).MultipleTimes().AndReturn('aabbcc') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'create_stack_domain_user') fakes.FakeKeystoneClient.create_stack_domain_user( username=self.username, password=password, project_id=project_id).AndReturn(user_id) self.m.ReplayAll() rsrc = user.User(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) with utils.UUIDStub(self.resource_id): scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_user(self): t = template_format.parse(user_template) stack = utils.parse_stack(t) rsrc = self.create_user(t, stack, 'CfnUser') self.assertEqual('dummy_user', rsrc.resource_id) self.assertEqual(self.username, rsrc.FnGetRefId()) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) self.assertIsNone(rsrc.handle_suspend()) self.assertIsNone(rsrc.handle_resume()) rsrc.resource_id = None scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) rsrc.resource_id = self.fc.access rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_user_password(self): t = template_format.parse(user_template_password) stack = utils.parse_stack(t) rsrc = self.create_user(t, stack, 'CfnUser', password=u'myP@ssW0rd') self.assertEqual('dummy_user', rsrc.resource_id) self.assertEqual(self.username, rsrc.FnGetRefId()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_user_validate_policies(self): t = template_format.parse(user_policy_template) stack = utils.parse_stack(t) rsrc = self.create_user(t, stack, 'CfnUser') self.assertEqual('dummy_user', rsrc.resource_id) self.assertEqual(self.username, rsrc.FnGetRefId()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual([u'WebServerAccessPolicy'], rsrc.properties['Policies']) # OK self.assertTrue(rsrc._validate_policies([u'WebServerAccessPolicy'])) # Resource name doesn't exist in the stack self.assertFalse(rsrc._validate_policies([u'NoExistAccessPolicy'])) # Resource name is wrong Resource type self.assertFalse(rsrc._validate_policies([u'NoExistAccessPolicy', u'WikiDatabase'])) # Wrong type (AWS embedded policy format, not yet supported) dict_policy = {"PolicyName": "AccessForCFNInit", "PolicyDocument": {"Statement": [{"Effect": "Allow", "Action": "cloudformation:DescribeStackResource", "Resource": "*"}]}} # However we should just ignore it to avoid breaking existing templates self.assertTrue(rsrc._validate_policies([dict_policy])) self.m.VerifyAll() def test_user_create_bad_policies(self): t = template_format.parse(user_policy_template) t['Resources']['CfnUser']['Properties']['Policies'] = ['NoExistBad'] stack = utils.parse_stack(t) resource_name = 'CfnUser' rsrc = user.User(resource_name, t['Resources'][resource_name], stack) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.handle_create) def test_user_access_allowed(self): self.m.StubOutWithMock(user.AccessPolicy, 'access_allowed') user.AccessPolicy.access_allowed('a_resource').AndReturn(True) user.AccessPolicy.access_allowed('b_resource').AndReturn(False) self.m.ReplayAll() t = template_format.parse(user_policy_template) stack = utils.parse_stack(t) rsrc = self.create_user(t, stack, 'CfnUser') self.assertEqual('dummy_user', rsrc.resource_id) self.assertEqual(self.username, rsrc.FnGetRefId()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertTrue(rsrc.access_allowed('a_resource')) self.assertFalse(rsrc.access_allowed('b_resource')) self.m.VerifyAll() def test_user_access_allowed_ignorepolicy(self): self.m.StubOutWithMock(user.AccessPolicy, 'access_allowed') user.AccessPolicy.access_allowed('a_resource').AndReturn(True) user.AccessPolicy.access_allowed('b_resource').AndReturn(False) self.m.ReplayAll() t = template_format.parse(user_policy_template) t['Resources']['CfnUser']['Properties']['Policies'] = [ 'WebServerAccessPolicy', {'an_ignored': 'policy'}] stack = utils.parse_stack(t) rsrc = self.create_user(t, stack, 'CfnUser') self.assertEqual('dummy_user', rsrc.resource_id) self.assertEqual(self.username, rsrc.FnGetRefId()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertTrue(rsrc.access_allowed('a_resource')) self.assertFalse(rsrc.access_allowed('b_resource')) self.m.VerifyAll() class AccessKeyTest(HeatTestCase): def setUp(self): super(AccessKeyTest, self).setUp() utils.setup_dummy_db() self.username = utils.PhysName('test_stack', 'CfnUser') self.credential_id = 'acredential123' self.fc = fakes.FakeKeystoneClient(username=self.username, user_id='dummy_user', credential_id=self.credential_id) cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role') def create_user(self, t, stack, resource_name, project_id='stackproject', user_id='dummy_user', password=None): self.m.StubOutWithMock(user.User, 'keystone') user.User.keystone().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() rsrc = stack[resource_name] self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_access_key(self, t, stack, resource_name): rsrc = user.AccessKey(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_access_key(self): t = template_format.parse(user_accesskey_template) stack = utils.parse_stack(t) self.create_user(t, stack, 'CfnUser') rsrc = self.create_access_key(t, stack, 'HostKeys') self.m.VerifyAll() self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) self.assertEqual(self.fc.access, rsrc.resource_id) self.assertEqual(self.fc.secret, rsrc._secret) # Ensure the resource data has been stored correctly rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual(self.fc.secret, rs_data.get('secret_key')) self.assertEqual(self.fc.credential_id, rs_data.get('credential_id')) self.assertEqual(2, len(rs_data.keys())) self.assertEqual(utils.PhysName(stack.name, 'CfnUser'), rsrc.FnGetAtt('UserName')) rsrc._secret = None self.assertEqual(self.fc.secret, rsrc.FnGetAtt('SecretAccessKey')) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_access_key_get_from_keystone(self): self.m.StubOutWithMock(user.AccessKey, 'keystone') user.AccessKey.keystone().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() t = template_format.parse(user_accesskey_template) stack = utils.parse_stack(t) self.create_user(t, stack, 'CfnUser') rsrc = self.create_access_key(t, stack, 'HostKeys') # Delete the resource data for secret_key, to test that existing # stacks which don't have the resource_data stored will continue # working via retrieving the keypair from keystone db_api.resource_data_delete(rsrc, 'credential_id') db_api.resource_data_delete(rsrc, 'secret_key') rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual(0, len(rs_data.keys())) rsrc._secret = None self.assertEqual(self.fc.secret, rsrc.FnGetAtt('SecretAccessKey')) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_access_key_no_user(self): self.m.ReplayAll() t = template_format.parse(user_accesskey_template) # Set the resource properties UserName to an unknown user t['Resources']['HostKeys']['Properties']['UserName'] = 'NonExistent' stack = utils.parse_stack(t) stack['CfnUser'].resource_id = self.fc.user_id rsrc = user.AccessKey('HostKeys', t['Resources']['HostKeys'], stack) create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() class AccessPolicyTest(HeatTestCase): def test_accesspolicy_create_ok(self): t = template_format.parse(user_policy_template) stack = utils.parse_stack(t) resource_name = 'WebServerAccessPolicy' rsrc = user.AccessPolicy(resource_name, t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) def test_accesspolicy_create_ok_empty(self): t = template_format.parse(user_policy_template) resource_name = 'WebServerAccessPolicy' t['Resources'][resource_name]['Properties']['AllowedResources'] = [] stack = utils.parse_stack(t) rsrc = user.AccessPolicy(resource_name, t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) def test_accesspolicy_create_err_notfound(self): t = template_format.parse(user_policy_template) resource_name = 'WebServerAccessPolicy' t['Resources'][resource_name]['Properties']['AllowedResources'] = [ 'NoExistResource'] stack = utils.parse_stack(t) self.assertRaises(exception.StackValidationFailed, stack.validate) def test_accesspolicy_update(self): t = template_format.parse(user_policy_template) resource_name = 'WebServerAccessPolicy' stack = utils.parse_stack(t) rsrc = user.AccessPolicy(resource_name, t['Resources'][resource_name], stack) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) def test_accesspolicy_access_allowed(self): t = template_format.parse(user_policy_template) resource_name = 'WebServerAccessPolicy' stack = utils.parse_stack(t) rsrc = user.AccessPolicy(resource_name, t['Resources'][resource_name], stack) self.assertTrue(rsrc.access_allowed('WikiDatabase')) self.assertFalse(rsrc.access_allowed('NotWikiDatabase')) self.assertFalse(rsrc.access_allowed(None)) heat-2014.1.5/heat/tests/test_plugin_loader.py0000664000567000056700000000524212540642614022354 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. import pkgutil import sys import testtools from heat.common import plugin_loader import heat.engine class PluginLoaderTest(testtools.TestCase): def test_module_name(self): self.assertEqual('foo.bar.blarg.wibble', plugin_loader._module_name('foo.bar', 'blarg.wibble')) def test_create_subpackage_single_path(self): pkg_name = 'heat.engine.test_single_path' self.assertNotIn(pkg_name, sys.modules) pkg = plugin_loader.create_subpackage('/tmp', 'heat.engine', 'test_single_path') self.assertIn(pkg_name, sys.modules) self.assertEqual(sys.modules[pkg_name], pkg) self.assertEqual(['/tmp'], pkg.__path__) self.assertEqual(pkg_name, pkg.__name__) def test_create_subpackage_path_list(self): path_list = ['/tmp'] pkg_name = 'heat.engine.test_path_list' self.assertNotIn(pkg_name, sys.modules) pkg = plugin_loader.create_subpackage('/tmp', 'heat.engine', 'test_path_list') self.assertIn(pkg_name, sys.modules) self.assertEqual(sys.modules[pkg_name], pkg) self.assertEqual(path_list, pkg.__path__) self.assertNotIn(pkg.__path__, path_list) self.assertEqual(pkg_name, pkg.__name__) def test_import_module_existing(self): import heat.engine.service existing = heat.engine.service importer = pkgutil.ImpImporter(heat.engine.__path__[0]) loaded = plugin_loader._import_module(importer, 'heat.engine.service', heat.engine) self.assertIs(existing, loaded) def test_import_module_garbage(self): importer = pkgutil.ImpImporter(heat.engine.__path__[0]) self.assertIsNone(plugin_loader._import_module(importer, 'wibble', heat.engine)) heat-2014.1.5/heat/tests/test_nokey.py0000664000567000056700000000603212540642614020653 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. from heat.common import template_format from heat.engine import clients from heat.engine.resources import instance as instances from heat.engine.resources import nova_utils from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes nokey_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "NoKey Test", "Parameters" : {}, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.large", "UserData" : "some data" } } } } ''' class nokeyTest(HeatTestCase): def setUp(self): super(nokeyTest, self).setUp() self.fc = fakes.FakeClient() utils.setup_dummy_db() def test_nokey_create(self): stack_name = 's_nokey' t = template_format.parse(nokey_template) stack = utils.parse_stack(t, stack_name=stack_name) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('create_instance_name', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name=None, name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() heat-2014.1.5/heat/tests/test_restarter.py0000664000567000056700000000647412540642614021553 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. import mock from heat.common import template_format from heat.engine.resources import instance from heat.engine import scheduler from heat.tests import common from heat.tests import utils restarter_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test HARestarter", "Parameters" : {}, "Resources" : { "restarter": { "Type": "OS::Heat::HARestarter", "Properties": { "InstanceId": "1234" } } } } ''' class RestarterTest(common.HeatTestCase): def setUp(self): super(RestarterTest, self).setUp() utils.setup_dummy_db() def create_restarter(self): snippet = template_format.parse(restarter_template) stack = utils.parse_stack(snippet) restarter = instance.Restarter( 'restarter', snippet['Resources']['restarter'], stack) restarter.handle_create = mock.Mock(return_value=None) return restarter def create_mock_instance(self, stack): inst = mock.Mock(spec=instance.Instance) inst.resource_id = '1234' inst.name = 'instance' stack.resources['instance'] = inst def test_create(self): rsrc = self.create_restarter() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rsrc.handle_create.assert_called_once_with() def test_handle_signal(self): rsrc = self.create_restarter() scheduler.TaskRunner(rsrc.create)() self.create_mock_instance(rsrc.stack) rsrc.stack.restart_resource = mock.Mock(return_value=None) self.assertIsNone(rsrc.handle_signal()) rsrc.stack.restart_resource.assert_called_once_with('instance') def test_handle_signal_alarm(self): rsrc = self.create_restarter() scheduler.TaskRunner(rsrc.create)() self.create_mock_instance(rsrc.stack) rsrc.stack.restart_resource = mock.Mock(return_value=None) self.assertIsNone(rsrc.handle_signal({'state': 'Alarm'})) rsrc.stack.restart_resource.assert_called_once_with('instance') def test_handle_signal_not_alarm(self): rsrc = self.create_restarter() scheduler.TaskRunner(rsrc.create)() self.create_mock_instance(rsrc.stack) rsrc.stack.restart_resource = mock.Mock(return_value=None) self.assertIsNone(rsrc.handle_signal({'state': 'spam'})) self.assertEqual([], rsrc.stack.restart_resource.mock_calls) def test_handle_signal_no_instance(self): rsrc = self.create_restarter() scheduler.TaskRunner(rsrc.create)() rsrc.stack.restart_resource = mock.Mock(return_value=None) self.assertIsNone(rsrc.handle_signal()) self.assertEqual([], rsrc.stack.restart_resource.mock_calls) heat-2014.1.5/heat/tests/test_sqlalchemy_filters.py0000664000567000056700000000314412540642614023421 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. import mock from heat.db.sqlalchemy import filters as db_filters from heat.tests.common import HeatTestCase class ExactFilterTest(HeatTestCase): def setUp(self): super(ExactFilterTest, self).setUp() self.query = mock.Mock() self.model = mock.Mock() def test_returns_same_query_for_empty_filters(self): filters = {} db_filters.exact_filter(self.query, self.model, filters) self.assertEqual(0, self.query.call_count) def test_add_exact_match_clause_for_single_values(self): filters = {'cat': 'foo'} db_filters.exact_filter(self.query, self.model, filters) self.query.filter_by.assert_called_once_with(cat='foo') def test_adds_an_in_clause_for_multiple_values(self): self.model.cat.in_.return_value = 'fake in clause' filters = {'cat': ['foo', 'quux']} db_filters.exact_filter(self.query, self.model, filters) self.query.filter.assert_called_once_with('fake in clause') self.model.cat.in_.assert_called_once_with(['foo', 'quux']) heat-2014.1.5/heat/tests/test_server_tags.py0000664000567000056700000002604612540642614022061 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. import copy import uuid import mox from heat.common import template_format from heat.engine import clients from heat.engine import environment from heat.engine import parser from heat.engine.resources import instance as instances from heat.engine.resources import nova_utils from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes instance_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "CentOS 5.2", "InstanceType" : "256 MB Server", "KeyName" : "test", "UserData" : "wordpress" } } } } ''' group_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "Config": { "Type": "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "CentOS 5.2", "InstanceType" : "256 MB Server", "KeyName" : "test", "UserData" : "wordpress" } }, "WebServer": { "Type": "OS::Heat::InstanceGroup", "Properties": { "AvailabilityZones" : ["nova"], "LaunchConfigurationName": { "Ref": "Config" }, "Size" : "1" } } } } ''' autoscaling_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "Config": { "Type": "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "CentOS 5.2", "InstanceType" : "256 MB Server", "KeyName" : "test", "UserData" : "wordpress" } }, "WebServer": { "Type": "AWS::AutoScaling::AutoScalingGroup", "Properties": { "AvailabilityZones" : ["nova"], "LaunchConfigurationName": { "Ref": "Config" }, "MinSize" : "1", "MaxSize" : "2", "Tags" : [{"Key" : "foo", "Value" : "42"}], } } } } ''' class ServerTagsTest(HeatTestCase): def setUp(self): super(ServerTagsTest, self).setUp() self.fc = fakes.FakeClient() utils.setup_dummy_db() def _setup_test_instance(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(instance_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['Tags'] = intags instance = instances.Instance(stack_name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return instance def test_instance_tags(self): tags = [{'Key': 'Food', 'Value': 'yum'}] metadata = dict((tm['Key'], tm['Value']) for tm in tags) instance = self._setup_test_instance(intags=tags, nova_tags=metadata) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() # we are just using mock to verify that the tags get through to the # nova call. self.m.VerifyAll() def test_instance_tags_updated(self): tags = [{'Key': 'Food', 'Value': 'yum'}] metadata = dict((tm['Key'], tm['Value']) for tm in tags) instance = self._setup_test_instance(intags=tags, nova_tags=metadata) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) # we are just using mock to verify that the tags get through to the # nova call. self.m.VerifyAll() self.m.UnsetStubs() new_tags = [{'Key': 'Food', 'Value': 'yuk'}] new_metadata = dict((tm['Key'], tm['Value']) for tm in new_tags) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc.servers, 'set_meta') self.fc.servers.set_meta(self.fc.servers.list()[1], new_metadata).AndReturn(None) self.m.ReplayAll() update_template = copy.deepcopy(instance.t) update_template['Properties']['Tags'] = new_tags scheduler.TaskRunner(instance.update, update_template)() self.assertEqual((instance.UPDATE, instance.COMPLETE), instance.state) self.m.VerifyAll() def _setup_test_group(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(group_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['Tags'] = intags # create the launch configuration conf = stack['Config'] self.assertIsNone(conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) group = stack['WebServer'] nova_tags['metering.groupname'] = utils.PhysName(stack.name, group.name) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return group def test_group_tags(self): tags = [{'Key': 'Food', 'Value': 'yum'}] metadata = dict((tm['Key'], tm['Value']) for tm in tags) group = self._setup_test_group(intags=tags, nova_tags=metadata) self.m.ReplayAll() scheduler.TaskRunner(group.create)() # we are just using mock to verify that the tags get through to the # nova call. self.m.VerifyAll() def _setup_test_group_autoscaling(self, intags=None, nova_tags=None): stack_name = 'tag_as_name' t = template_format.parse(autoscaling_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['Tags'] += intags # create the launch configuration conf = stack['Config'] self.assertIsNone(conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) group = stack['WebServer'] group_refid = utils.PhysName(stack.name, group.name) nova_tags['metering.groupname'] = group_refid nova_tags['AutoScalingGroupName'] = group_refid self.m.StubOutWithMock(group, '_cooldown_timestamp') group._cooldown_timestamp(mox.IgnoreArg()).AndReturn(None) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return group def test_as_group_tags(self): tags = [{'Key': 'Food', 'Value': 'yum'}, {'Key': 'foo', 'Value': '42'}] metadata = dict((tm['Key'], tm['Value']) for tm in tags) group = self._setup_test_group_autoscaling(intags=[tags[0]], nova_tags=metadata) self.m.ReplayAll() scheduler.TaskRunner(group.create)() # we are just using mock to verify that the tags get through to the # nova call. self.m.VerifyAll() heat-2014.1.5/heat/tests/test_resource.py0000664000567000056700000015034012540642614021357 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. import itertools import json import uuid import mock from heat.common import exception import heat.db.api as db_api from heat.engine import dependencies from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.engine import template from heat.openstack.common.gettextutils import _ from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import utils class ResourceTest(HeatTestCase): def setUp(self): super(ResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) env = environment.Environment() env.load({u'resource_registry': {u'OS::Test::GenericResource': u'GenericResourceType'}}) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=str(uuid.uuid4())) def test_get_class_ok(self): cls = resource.get_class('GenericResourceType') self.assertEqual(generic_rsrc.GenericResource, cls) def test_get_class_noexist(self): self.assertRaises(exception.StackValidationFailed, resource.get_class, 'NoExistResourceType') def test_resource_new_ok(self): snippet = {'Type': 'GenericResourceType'} res = resource.Resource('aresource', snippet, self.stack) self.assertIsInstance(res, generic_rsrc.GenericResource) self.assertEqual("INIT", res.action) def test_resource_new_stack_not_stored(self): snippet = {'Type': 'GenericResourceType'} self.stack.id = None db_method = 'resource_get_by_name_and_stack' with mock.patch.object(db_api, db_method) as resource_get: res = resource.Resource('aresource', snippet, self.stack) self.assertEqual("INIT", res.action) self.assertIs(False, resource_get.called) def test_resource_new_err(self): snippet = {'Type': 'NoExistResourceType'} self.assertRaises(exception.StackValidationFailed, resource.Resource, 'aresource', snippet, self.stack) def test_resource_non_type(self): snippet = {'Type': ''} resource_name = 'aresource' ex = self.assertRaises(exception.StackValidationFailed, resource.Resource, resource_name, snippet, self.stack) self.assertIn(_('Resource "%s" has no type') % resource_name, str(ex)) def test_resource_wrong_type(self): snippet = {'Type': {}} resource_name = 'aresource' ex = self.assertRaises(exception.StackValidationFailed, resource.Resource, resource_name, snippet, self.stack) self.assertIn(_('Resource "%s" type is not a string') % resource_name, str(ex)) def test_resource_missed_type(self): snippet = {'not-a-Type': 'GenericResourceType'} resource_name = 'aresource' ex = self.assertRaises(exception.StackValidationFailed, resource.Resource, resource_name, snippet, self.stack) self.assertIn(_('Non-empty resource type is required ' 'for resource "%s"') % resource_name, str(ex)) def test_state_defaults(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_res_def', tmpl, self.stack) self.assertEqual((res.INIT, res.COMPLETE), res.state) self.assertEqual('', res.status_reason) def test_resource_str_repr_stack_id_resource_id(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_res_str_repr', tmpl, self.stack) res.stack.id = "123" res.resource_id = "456" expected = ('GenericResource "test_res_str_repr" [456] Stack ' '"test_stack" [123]') observed = str(res) self.assertEqual(expected, observed) def test_resource_str_repr_stack_id_no_resource_id(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_res_str_repr', tmpl, self.stack) res.stack.id = "123" res.resource_id = None expected = ('GenericResource "test_res_str_repr" Stack "test_stack" ' '[123]') observed = str(res) self.assertEqual(expected, observed) def test_resource_str_repr_no_stack_id(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_res_str_repr', tmpl, self.stack) res.stack.id = None expected = ('GenericResource "test_res_str_repr"') observed = str(res) self.assertEqual(expected, observed) def test_state_set(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.state_set(res.CREATE, res.COMPLETE, 'wibble') self.assertEqual(res.CREATE, res.action) self.assertEqual(res.COMPLETE, res.status) self.assertEqual((res.CREATE, res.COMPLETE), res.state) self.assertEqual('wibble', res.status_reason) def test_set_deletion_policy(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.set_deletion_policy(resource.RETAIN) self.assertEqual(resource.RETAIN, res.t['DeletionPolicy']) res.set_deletion_policy(resource.DELETE) self.assertEqual(resource.DELETE, res.t['DeletionPolicy']) def test_get_abandon_data(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) expected = { 'action': 'INIT', 'metadata': {}, 'name': 'test_resource', 'resource_data': {}, 'resource_id': None, 'status': 'COMPLETE', 'type': 'Foo' } actual = res.get_abandon_data() self.assertEqual(expected, actual) def test_abandon_with_resource_data(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.m.StubOutWithMock(db_api, 'resource_data_get_all') db_api.resource_data_get_all(res).AndReturn({"test-key": "test-value"}) self.m.ReplayAll() expected = { 'action': 'INIT', 'metadata': {}, 'name': 'test_resource', 'resource_data': {"test-key": "test-value"}, 'resource_id': None, 'status': 'COMPLETE', 'type': 'Foo' } actual = res.get_abandon_data() self.assertEqual(expected, actual) self.m.VerifyAll() def test_state_set_invalid(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertRaises(ValueError, res.state_set, 'foo', 'bla') self.assertRaises(ValueError, res.state_set, 'foo', res.COMPLETE) self.assertRaises(ValueError, res.state_set, res.CREATE, 'bla') def test_state_del_stack(self): tmpl = {'Type': 'Foo'} self.stack.action = self.stack.DELETE self.stack.status = self.stack.IN_PROGRESS res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertEqual(res.DELETE, res.action) self.assertEqual(res.COMPLETE, res.status) def test_type(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertEqual('Foo', res.type()) def test_has_interface_direct_match(self): tmpl = {'Type': 'GenericResourceType'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertTrue(res.has_interface('GenericResourceType')) def test_has_interface_no_match(self): tmpl = {'Type': 'GenericResourceType'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertFalse(res.has_interface('LookingForAnotherType')) def test_has_interface_mapping(self): tmpl = {'Type': 'OS::Test::GenericResource'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertTrue(res.has_interface('GenericResourceType')) def test_created_time(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_res_new', tmpl, self.stack) self.assertIsNone(res.created_time) res._store() self.assertIsNotNone(res.created_time) def test_updated_time(self): tmpl = {'Type': 'GenericResourceType'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Type',) res._store() stored_time = res.updated_time utmpl = {'Type': 'Foo'} scheduler.TaskRunner(res.update, utmpl)() self.assertIsNotNone(res.updated_time) self.assertNotEqual(res.updated_time, stored_time) def test_updated_time_changes_only_on_update_calls(self): tmpl = {'Type': 'GenericResourceType'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Type',) res._store() self.assertIsNone(res.updated_time) res._store_or_update(res.UPDATE, res.COMPLETE, 'should not change') self.assertIsNone(res.updated_time) def test_store_or_update(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_res_upd', tmpl, self.stack) res._store_or_update(res.CREATE, res.IN_PROGRESS, 'test_store') self.assertIsNotNone(res.id) self.assertEqual(res.CREATE, res.action) self.assertEqual(res.IN_PROGRESS, res.status) self.assertEqual('test_store', res.status_reason) db_res = db_api.resource_get(res.context, res.id) self.assertEqual(res.CREATE, db_res.action) self.assertEqual(res.IN_PROGRESS, db_res.status) self.assertEqual('test_store', db_res.status_reason) res._store_or_update(res.CREATE, res.COMPLETE, 'test_update') self.assertEqual(res.CREATE, res.action) self.assertEqual(res.COMPLETE, res.status) self.assertEqual('test_update', res.status_reason) self.assertEqual(res.CREATE, db_res.action) self.assertEqual(res.COMPLETE, db_res.status) self.assertEqual('test_update', db_res.status_reason) def test_parsed_template(self): tmpl = { 'Type': 'Foo', 'foo': {'Fn::Join': [' ', ['bar', 'baz', 'quux']]} } res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) parsed_tmpl = res.parsed_template() self.assertEqual('Foo', parsed_tmpl['Type']) self.assertEqual('bar baz quux', parsed_tmpl['foo']) self.assertEqual('bar baz quux', res.parsed_template('foo')) self.assertEqual('bar baz quux', res.parsed_template('foo', 'bar')) def test_parsed_template_default(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertEqual({}, res.parsed_template('foo')) self.assertEqual('bar', res.parsed_template('foo', 'bar')) def test_metadata_default(self): tmpl = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertEqual({}, res.metadata) def test_equals_different_stacks(self): tmpl1 = {'Type': 'Foo'} tmpl2 = {'Type': 'Foo'} tmpl3 = {'Type': 'Bar'} stack2 = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), stack_id=-1) res1 = generic_rsrc.GenericResource('test_resource', tmpl1, self.stack) res2 = generic_rsrc.GenericResource('test_resource', tmpl2, stack2) res3 = generic_rsrc.GenericResource('test_resource2', tmpl3, stack2) self.assertEqual(res1, res2) self.assertNotEqual(res1, res3) def test_equals_names(self): tmpl1 = {'Type': 'Foo'} tmpl2 = {'Type': 'Foo'} res1 = generic_rsrc.GenericResource('test_resource1', tmpl1, self.stack) res2 = generic_rsrc.GenericResource('test_resource2', tmpl2, self.stack) self.assertNotEqual(res1, res2) def test_update_template_diff_empty(self): tmpl = {'Type': 'Foo'} update_snippet = {} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertRaises(resource.UpdateReplace, res.update_template_diff, update_snippet, tmpl) def test_update_template_diff_changed_notallowed(self): tmpl = {'Type': 'Foo'} update_snippet = {'Type': 'Bar'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) self.assertRaises(resource.UpdateReplace, res.update_template_diff, update_snippet, tmpl) def test_update_template_diff_changed_modified(self): tmpl = {'Type': 'Foo', 'Metadata': {'foo': 123}} update_snippet = {'Type': 'Foo', 'Metadata': {'foo': 456}} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Metadata',) diff = res.update_template_diff(update_snippet, tmpl) self.assertEqual({'Metadata': {'foo': 456}}, diff) def test_update_template_diff_changed_add(self): tmpl = {'Type': 'Foo'} update_snippet = {'Type': 'Foo', 'Metadata': {'foo': 123}} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Metadata',) diff = res.update_template_diff(update_snippet, tmpl) self.assertEqual({'Metadata': {'foo': 123}}, diff) def test_update_template_diff_changed_remove(self): tmpl = {'Type': 'Foo', 'Metadata': {'foo': 123}} update_snippet = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Metadata',) diff = res.update_template_diff(update_snippet, tmpl) self.assertEqual({'Metadata': None}, diff) def test_update_template_diff_properties_none(self): tmpl = {'Type': 'Foo'} update_snippet = {'Type': 'Foo'} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) diff = res.update_template_diff_properties(update_snippet, tmpl) self.assertEqual({}, diff) def test_update_template_diff_properties_added(self): tmpl = {'Type': 'Foo'} update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 123}} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_properties = ('Bar',) diff = res.update_template_diff_properties(update_snippet, tmpl) self.assertEqual({'Bar': 123}, diff) def test_update_template_diff_properties_removed(self): tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}} update_snippet = {'Type': 'Foo', 'Properties': {}} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_properties = ('Bar',) diff = res.update_template_diff_properties(update_snippet, tmpl) self.assertEqual({'Bar': None}, diff) def test_update_template_diff_properties_changed(self): tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}} update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 456}} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_properties = ('Bar',) diff = res.update_template_diff_properties(update_snippet, tmpl) self.assertEqual({'Bar': 456}, diff) def test_update_template_diff_properties_notallowed(self): tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}} update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 456}} res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack) res.update_allowed_properties = ('Cat',) self.assertRaises(resource.UpdateReplace, res.update_template_diff_properties, update_snippet, tmpl) def test_resource(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) def test_create_fail_missing_req_prop(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {}} rname = 'test_resource' res = generic_rsrc.ResourceWithRequiredProps(rname, tmpl, self.stack) estr = 'Property error : test_resource: Property Foo not assigned' create = scheduler.TaskRunner(res.create) err = self.assertRaises(exception.ResourceFailure, create) self.assertIn(estr, str(err)) self.assertEqual((res.CREATE, res.FAILED), res.state) def test_create_fail_prop_typo(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Food': 'abc'}} rname = 'test_resource' res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack) estr = 'StackValidationFailed: Unknown Property Food' create = scheduler.TaskRunner(res.create) err = self.assertRaises(exception.ResourceFailure, create) self.assertIn(estr, str(err)) self.assertEqual((res.CREATE, res.FAILED), res.state) def test_create_fail_metadata_parse_error(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {}, 'Metadata': {"Fn::GetAtt": ["ResourceA", "abc"]}} rname = 'test_resource' res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack) create = scheduler.TaskRunner(res.create) self.assertRaises(exception.ResourceFailure, create) self.assertEqual((res.CREATE, res.FAILED), res.state) def test_create_resource_after_destroy(self): tmpl = {'Type': 'GenericResourceType'} rname = 'test_res_id_none' res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack) res.id = 'test_res_id' (res.action, res.status) = (res.INIT, res.DELETE) self.assertRaises(exception.ResourceFailure, res.create) scheduler.TaskRunner(res.destroy)() res.state_reset() scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) def test_preview(self): tmpl = {'Type': 'GenericResourceType'} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) self.assertEqual(res, res.preview()) def test_update_ok(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) utmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'xyz'}} tmpl_diff = {'Properties': {'Foo': 'xyz'}} prop_diff = {'Foo': 'xyz'} self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') generic_rsrc.ResourceWithProps.handle_update( utmpl, tmpl_diff, prop_diff).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(res.update, utmpl)() self.assertEqual((res.UPDATE, res.COMPLETE), res.state) self.m.VerifyAll() def test_update_replace(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) utmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'xyz'}} self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') tmpl_diff = {'Properties': {'Foo': 'xyz'}} prop_diff = {'Foo': 'xyz'} generic_rsrc.ResourceWithProps.handle_update( utmpl, tmpl_diff, prop_diff).AndRaise(resource.UpdateReplace()) self.m.ReplayAll() # should be re-raised so parser.Stack can handle replacement updater = scheduler.TaskRunner(res.update, utmpl) self.assertRaises(resource.UpdateReplace, updater) self.m.VerifyAll() def test_update_fail_missing_req_prop(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithRequiredProps('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) utmpl = {'Type': 'GenericResourceType', 'Properties': {}} updater = scheduler.TaskRunner(res.update, utmpl) self.assertRaises(exception.ResourceFailure, updater) self.assertEqual((res.UPDATE, res.FAILED), res.state) def test_update_fail_prop_typo(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) utmpl = {'Type': 'GenericResourceType', 'Properties': {'Food': 'xyz'}} updater = scheduler.TaskRunner(res.update, utmpl) self.assertRaises(exception.ResourceFailure, updater) self.assertEqual((res.UPDATE, res.FAILED), res.state) def test_update_not_implemented(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) utmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'xyz'}} tmpl_diff = {'Properties': {'Foo': 'xyz'}} prop_diff = {'Foo': 'xyz'} self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') generic_rsrc.ResourceWithProps.handle_update( utmpl, tmpl_diff, prop_diff).AndRaise(NotImplemented) self.m.ReplayAll() updater = scheduler.TaskRunner(res.update, utmpl) self.assertRaises(exception.ResourceFailure, updater) self.assertEqual((res.UPDATE, res.FAILED), res.state) self.m.VerifyAll() def test_suspend_resume_ok(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) scheduler.TaskRunner(res.suspend)() self.assertEqual((res.SUSPEND, res.COMPLETE), res.state) scheduler.TaskRunner(res.resume)() self.assertEqual((res.RESUME, res.COMPLETE), res.state) def test_suspend_fail_inprogress(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) res.state_set(res.CREATE, res.IN_PROGRESS) suspend = scheduler.TaskRunner(res.suspend) self.assertRaises(exception.ResourceFailure, suspend) res.state_set(res.UPDATE, res.IN_PROGRESS) suspend = scheduler.TaskRunner(res.suspend) self.assertRaises(exception.ResourceFailure, suspend) res.state_set(res.DELETE, res.IN_PROGRESS) suspend = scheduler.TaskRunner(res.suspend) self.assertRaises(exception.ResourceFailure, suspend) def test_resume_fail_not_suspend_complete(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) non_suspended_states = [s for s in itertools.product(res.ACTIONS, res.STATUSES) if s != (res.SUSPEND, res.COMPLETE)] for state in non_suspended_states: res.state_set(*state) resume = scheduler.TaskRunner(res.resume) self.assertRaises(exception.ResourceFailure, resume) def test_suspend_fail_exception(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_suspend') generic_rsrc.ResourceWithProps.handle_suspend().AndRaise(Exception()) self.m.ReplayAll() suspend = scheduler.TaskRunner(res.suspend) self.assertRaises(exception.ResourceFailure, suspend) self.assertEqual((res.SUSPEND, res.FAILED), res.state) def test_resume_fail_exception(self): tmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'abc'}} res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack) scheduler.TaskRunner(res.create)() self.assertEqual((res.CREATE, res.COMPLETE), res.state) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_resume') generic_rsrc.ResourceWithProps.handle_resume().AndRaise(Exception()) self.m.ReplayAll() res.state_set(res.SUSPEND, res.COMPLETE) resume = scheduler.TaskRunner(res.resume) self.assertRaises(exception.ResourceFailure, resume) self.assertEqual((res.RESUME, res.FAILED), res.state) def test_resource_class_to_template(self): class TestResource(resource.Resource): list_schema = {'wont_show_up': {'Type': 'Number'}} map_schema = {'will_show_up': {'Type': 'Integer'}} properties_schema = { 'name': {'Type': 'String'}, 'bool': {'Type': 'Boolean'}, 'implemented': {'Type': 'String', 'Implemented': True, 'AllowedPattern': '.*', 'MaxLength': 7, 'MinLength': 2, 'Required': True}, 'not_implemented': {'Type': 'String', 'Implemented': False}, 'number': {'Type': 'Number', 'MaxValue': 77, 'MinValue': 41, 'Default': 42}, 'list': {'Type': 'List', 'Schema': {'Type': 'Map', 'Schema': list_schema}}, 'map': {'Type': 'Map', 'Schema': map_schema}, } attributes_schema = { 'output1': 'output1_desc', 'output2': 'output2_desc' } expected_template = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'name': {'Type': 'String'}, 'bool': {'Type': 'String', 'AllowedValues': ['True', 'true', 'False', 'false']}, 'implemented': { 'Type': 'String', 'AllowedPattern': '.*', 'MaxLength': 7, 'MinLength': 2 }, 'number': {'Type': 'Number', 'MaxValue': 77, 'MinValue': 41, 'Default': 42}, 'list': {'Type': 'CommaDelimitedList'}, 'map': {'Type': 'Json'} }, 'Resources': { 'TestResource': { 'Type': 'Test::Resource::resource', 'Properties': { 'name': {'Ref': 'name'}, 'bool': {'Ref': 'bool'}, 'implemented': {'Ref': 'implemented'}, 'number': {'Ref': 'number'}, 'list': {'Fn::Split': [",", {'Ref': 'list'}]}, 'map': {'Ref': 'map'} } } }, 'Outputs': { 'output1': { 'Description': 'output1_desc', 'Value': '{"Fn::GetAtt": ["TestResource", "output1"]}' }, 'output2': { 'Description': 'output2_desc', 'Value': '{"Fn::GetAtt": ["TestResource", "output2"]}' } } } self.assertEqual(expected_template, TestResource.resource_to_template( 'Test::Resource::resource')) class ResourceAdoptTest(HeatTestCase): def setUp(self): super(ResourceAdoptTest, self).setUp() utils.setup_dummy_db() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) def test_adopt_resource_success(self): adopt_data = '{}' tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, } }) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', tmpl, stack_id=str(uuid.uuid4()), adopt_stack_data=json.loads(adopt_data)) res = self.stack['foo'] res_data = { "status": "COMPLETE", "name": "foo", "resource_data": {}, "metadata": {}, "resource_id": "test-res-id", "action": "CREATE", "type": "GenericResourceType" } adopt = scheduler.TaskRunner(res.adopt, res_data) adopt() self.assertEqual({}, res.metadata) self.assertEqual((res.ADOPT, res.COMPLETE), res.state) def test_adopt_with_resource_data_and_metadata(self): adopt_data = '{}' tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, } }) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', tmpl, stack_id=str(uuid.uuid4()), adopt_stack_data=json.loads(adopt_data)) res = self.stack['foo'] res_data = { "status": "COMPLETE", "name": "foo", "resource_data": {"test-key": "test-value"}, "metadata": {"os_distro": "test-distro"}, "resource_id": "test-res-id", "action": "CREATE", "type": "GenericResourceType" } adopt = scheduler.TaskRunner(res.adopt, res_data) adopt() self.assertEqual("test-value", db_api.resource_data_get(res, "test-key")) self.assertEqual({"os_distro": "test-distro"}, res.metadata) self.assertEqual((res.ADOPT, res.COMPLETE), res.state) def test_adopt_resource_missing(self): adopt_data = '''{ "action": "CREATE", "status": "COMPLETE", "name": "my-test-stack-name", "resources": {} }''' tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, } }) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', tmpl, stack_id=str(uuid.uuid4()), adopt_stack_data=json.loads(adopt_data)) res = self.stack['foo'] adopt = scheduler.TaskRunner(res.adopt, None) self.assertRaises(exception.ResourceFailure, adopt) expected = 'Exception: Resource ID was not provided.' self.assertEqual(expected, res.status_reason) class ResourceDependenciesTest(HeatTestCase): def setUp(self): super(ResourceDependenciesTest, self).setUp() utils.setup_dummy_db() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) resource._register_class('ResourceWithPropsType', generic_rsrc.ResourceWithProps) self.deps = dependencies.Dependencies() def test_no_deps(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['foo'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) def test_ref(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'foo'}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_hot_ref(self): '''Test that HOT get_resource creates dependencies.''' tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'get_resource': 'foo'}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_ref_nested_dict(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::Base64': {'Ref': 'foo'}}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_hot_ref_nested_dict(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'Fn::Base64': {'get_resource': 'foo'}}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_ref_nested_deep(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::Join': [",", ["blarg", {'Ref': 'foo'}, "wibble"]]}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_hot_ref_nested_deep(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'foo': {'Fn::Join': [",", ["blarg", {'get_resource': 'foo'}, "wibble"]]}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_ref_fail(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'baz'}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"baz" (in bar.Properties.Foo)', str(ex)) def test_hot_ref_fail(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'get_resource': 'baz'}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"baz" (in bar.Properties.Foo)', str(ex)) def test_getatt(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::GetAtt': ['foo', 'bar']}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_hot_getatt(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'get_attr': ['foo', 'bar']}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_getatt_nested_dict(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::Base64': {'Fn::GetAtt': ['foo', 'bar']}}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_hot_getatt_nested_dict(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'Fn::Base64': {'get_attr': ['foo', 'bar']}}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_getatt_nested_deep(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::Join': [",", ["blarg", {'Fn::GetAtt': ['foo', 'bar']}, "wibble"]]}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_hot_getatt_nested_deep(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'Fn::Join': [",", ["blarg", {'get_attr': ['foo', 'bar']}, "wibble"]]}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_getatt_fail(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::GetAtt': ['baz', 'bar']}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"baz" (in bar.Properties.Foo)', str(ex)) def test_hot_getatt_fail(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'get_attr': ['baz', 'bar']}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"baz" (in bar.Properties.Foo)', str(ex)) def test_getatt_fail_nested_deep(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Fn::Join': [",", ["blarg", {'Fn::GetAtt': ['foo', 'bar']}, "wibble", {'Fn::GetAtt': ['baz', 'bar']}]]}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"baz" (in bar.Properties.Foo.Fn::Join[1][3])', str(ex)) def test_hot_getatt_fail_nested_deep(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'ResourceWithPropsType', 'properties': { 'Foo': {'Fn::Join': [",", ["blarg", {'get_attr': ['foo', 'bar']}, "wibble", {'get_attr': ['baz', 'bar']}]]}, } } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"baz" (in bar.Properties.Foo.Fn::Join[1][3])', str(ex)) def test_dependson(self): tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'GenericResourceType', 'DependsOn': 'foo', } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_dependson_hot(self): tmpl = template.Template({ 'heat_template_version': '2013-05-23', 'resources': { 'foo': {'type': 'GenericResourceType'}, 'bar': { 'type': 'GenericResourceType', 'depends_on': 'foo', } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) res = stack['bar'] res.add_dependencies(self.deps) graph = self.deps.graph() self.assertIn(res, graph) self.assertIn(stack['foo'], graph[res]) def test_dependson_fail(self): tmpl = template.Template({ 'Resources': { 'foo': { 'Type': 'GenericResourceType', 'DependsOn': 'wibble', } } }) stack = parser.Stack(utils.dummy_context(), 'test', tmpl) ex = self.assertRaises(exception.InvalidTemplateReference, getattr, stack, 'dependencies') self.assertIn('"wibble" (in foo)', str(ex)) class MetadataTest(HeatTestCase): def setUp(self): super(MetadataTest, self).setUp() tmpl = { 'Type': 'Foo', 'Metadata': {'Test': 'Initial metadata'} } utils.setup_dummy_db() self.stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({})) self.stack.store() self.res = generic_rsrc.GenericResource('metadata_resource', tmpl, self.stack) scheduler.TaskRunner(self.res.create)() self.addCleanup(self.stack.delete) def test_read_initial(self): self.assertEqual({'Test': 'Initial metadata'}, self.res.metadata) def test_write(self): test_data = {'Test': 'Newly-written data'} self.res.metadata = test_data self.assertEqual(test_data, self.res.metadata) class ReducePhysicalResourceNameTest(HeatTestCase): scenarios = [ ('one', dict( limit=10, original='one', reduced='one')), ('limit_plus_one', dict( will_reduce=True, limit=10, original='onetwothree', reduced='on-wothree')), ('limit_exact', dict( limit=11, original='onetwothree', reduced='onetwothree')), ('limit_minus_one', dict( limit=12, original='onetwothree', reduced='onetwothree')), ('limit_four', dict( will_reduce=True, limit=4, original='onetwothree', reduced='on-e')), ('limit_three', dict( will_raise=ValueError, limit=3, original='onetwothree')), ('three_nested_stacks', dict( will_reduce=True, limit=63, original=('ElasticSearch-MasterCluster-ccicxsm25ug6-MasterSvr1' '-men65r4t53hh-MasterServer-gxpc3wqxy4el'), reduced=('El-icxsm25ug6-MasterSvr1-men65r4t53hh-' 'MasterServer-gxpc3wqxy4el'))), ('big_names', dict( will_reduce=True, limit=63, original=('MyReallyQuiteVeryLongStackName-' 'MyExtraordinarilyLongResourceName-ccicxsm25ug6'), reduced=('My-LongStackName-' 'MyExtraordinarilyLongResourceName-ccicxsm25ug6'))), ] will_raise = None will_reduce = False def test_reduce(self): if self.will_raise: self.assertRaises( self.will_raise, resource.Resource.reduce_physical_resource_name, self.original, self.limit) else: reduced = resource.Resource.reduce_physical_resource_name( self.original, self.limit) self.assertEqual(self.reduced, reduced) if self.will_reduce: # check it has been truncated to exactly the limit self.assertEqual(self.limit, len(reduced)) else: # check that nothing has changed self.assertEqual(self.original, reduced) heat-2014.1.5/heat/tests/test_exception.py0000664000567000056700000000207512540642614021527 0ustar jenkinsjenkins00000000000000# Copyright 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. import fixtures from heat.common import exception from heat.tests import common class TestException(exception.HeatException): msg_fmt = _("Testing message %(text)s") class TestHeatException(common.HeatTestCase): def test_fatal_exception_error(self): self.useFixture(fixtures.MonkeyPatch( 'heat.common.exception._FATAL_EXCEPTION_FORMAT_ERRORS', True)) self.assertRaises(KeyError, TestException) heat-2014.1.5/heat/tests/test_scaling_template.py0000664000567000056700000000755112540642614023050 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. import itertools from heat.common import short_id from heat.scaling import template from heat.tests.common import HeatTestCase class ResourceTemplatesTest(HeatTestCase): def setUp(self): super(ResourceTemplatesTest, self).setUp() ids = ('stubbed-id-%s' % (i,) for i in itertools.count()) self.patchobject(short_id, 'generate_id').side_effect = ids.next def test_create_template(self): """ When creating a template from scratch, an empty list is accepted as the "old" resources and new resources are created up to num_resource. """ templates = template.resource_templates([], {'type': 'Foo'}, 2, 0) expected = [ ('stubbed-id-0', {'type': 'Foo'}), ('stubbed-id-1', {'type': 'Foo'})] self.assertEqual(expected, list(templates)) def test_replace_template(self): """ If num_replace is the number of old resources, then all of the resources will be replaced. """ old_resources = [ ('old-id-0', {'type': 'Foo'}), ('old-id-1', {'type': 'Foo'})] templates = template.resource_templates(old_resources, {'type': 'Bar'}, 1, 2) expected = [('old-id-1', {'type': 'Bar'})] self.assertEqual(expected, list(templates)) def test_replace_some_units(self): """ If the resource definition changes, only the number of replacements specified will be made; beyond that, the original templates are used. """ old_resources = [ ('old-id-0', {'type': 'Foo'}), ('old-id-1', {'type': 'Foo'})] new_spec = {'type': 'Bar'} templates = template.resource_templates(old_resources, new_spec, 2, 1) expected = [ ('old-id-0', {'type': 'Bar'}), ('old-id-1', {'type': 'Foo'})] self.assertEqual(expected, list(templates)) def test_growth_counts_as_replacement(self): """ If we grow the template and replace some elements at the same time, the number of replacements to perform is reduced by the number of new resources to be created. """ spec = {'type': 'Foo'} old_resources = [ ('old-id-0', spec), ('old-id-1', spec)] new_spec = {'type': 'Bar'} templates = template.resource_templates(old_resources, new_spec, 4, 2) expected = [ ('old-id-0', spec), ('old-id-1', spec), ('stubbed-id-0', new_spec), ('stubbed-id-1', new_spec)] self.assertEqual(expected, list(templates)) def test_replace_units_some_already_up_to_date(self): """ If some of the old resources already have the new resource definition, then they won't be considered for replacement, and the next resource that is out-of-date will be replaced. """ old_resources = [ ('old-id-0', {'type': 'Bar'}), ('old-id-1', {'type': 'Foo'})] new_spec = {'type': 'Bar'} templates = template.resource_templates(old_resources, new_spec, 2, 1) second_batch_expected = [ ('old-id-0', {'type': 'Bar'}), ('old-id-1', {'type': 'Bar'})] self.assertEqual(second_batch_expected, list(templates)) heat-2014.1.5/heat/tests/test_short_id.py0000664000567000056700000000530712540642614021345 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. import testtools from heat.common import short_id import uuid class ShortIdTest(testtools.TestCase): def test_byte_string_8(self): self.assertEqual('\xab', short_id._to_byte_string(0xab, 8)) self.assertEqual('\x05', short_id._to_byte_string(0x05, 8)) def test_byte_string_16(self): self.assertEqual('\xab\xcd', short_id._to_byte_string(0xabcd, 16)) self.assertEqual('\x0a\xbc', short_id._to_byte_string(0xabc, 16)) def test_byte_string_12(self): self.assertEqual('\xab\xc0', short_id._to_byte_string(0xabc, 12)) self.assertEqual('\x0a\xb0', short_id._to_byte_string(0x0ab, 12)) def test_byte_string_60(self): val = 0x111111111111111 byte_string = short_id._to_byte_string(val, 60) self.assertEqual('\x11\x11\x11\x11\x11\x11\x11\x10', byte_string) def test_get_id_string(self): id = short_id.get_id('11111111-1111-4111-bfff-ffffffffffff') self.assertEqual('ceirceirceir', id) def test_get_id_uuid_1(self): source = uuid.UUID('11111111-1111-4111-bfff-ffffffffffff') self.assertEqual(0x111111111111111, source.time) self.assertEqual('ceirceirceir', short_id.get_id(source)) def test_get_id_uuid_f(self): source = uuid.UUID('ffffffff-ffff-4fff-8000-000000000000') self.assertEqual('777777777777', short_id.get_id(source)) def test_get_id_uuid_0(self): source = uuid.UUID('00000000-0000-4000-bfff-ffffffffffff') self.assertEqual('aaaaaaaaaaaa', short_id.get_id(source)) def test_get_id_uuid_endianness(self): source = uuid.UUID('ffffffff-00ff-4000-aaaa-aaaaaaaaaaaa') self.assertEqual('aaaa77777777', short_id.get_id(source)) def test_get_id_uuid1(self): source = uuid.uuid1() self.assertRaises(ValueError, short_id.get_id, source) def test_generate_ids(self): allowed_chars = 'abcdefghijklmnopqrstuvwxyz234567' ids = [short_id.generate_id() for i in range(25)] for id in ids: self.assertEqual(12, len(id)) self.assertFalse(id.translate(None, allowed_chars)) self.assertEqual(1, ids.count(id)) heat-2014.1.5/heat/tests/test_loguserdata.py0000664000567000056700000001246012540642614022042 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. import errno import mox import os import pkg_resources import subprocess from heat.cloudinit import loguserdata from heat.tests.common import HeatTestCase class FakeCiVersion(object): def __init__(self, version=None): self.version = version class FakePOpen(object): def __init__(self, returncode=0): self.returncode = returncode def wait(self): pass def communicate(self, input=None): pass class LoguserdataTest(HeatTestCase): def setUp(self): super(LoguserdataTest, self).setUp() self.m.StubOutWithMock(pkg_resources, 'get_distribution') self.m.StubOutWithMock(subprocess, 'Popen') self.m.StubOutWithMock(os, 'chmod') def test_ci_version(self): # too old versions pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.5.0')) pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.5.9')) # new enough versions pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.6.0')) pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.7.0')) pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('1.0')) pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('2.0')) self.m.ReplayAll() self.assertFalse(loguserdata.chk_ci_version()) self.assertFalse(loguserdata.chk_ci_version()) self.assertTrue(loguserdata.chk_ci_version()) self.assertTrue(loguserdata.chk_ci_version()) self.assertTrue(loguserdata.chk_ci_version()) self.assertTrue(loguserdata.chk_ci_version()) self.m.VerifyAll() def test_call(self): subprocess.Popen( ['echo', 'hi'], stderr=mox.IgnoreArg(), stdout=mox.IgnoreArg()).AndReturn(FakePOpen(0)) self.m.ReplayAll() self.assertEqual(0, loguserdata.call(['echo', 'hi'])) self.m.VerifyAll() def test_main(self): pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.7.0')) os.chmod('/var/lib/heat-cfntools/cfn-userdata', 0o700).AndReturn(None) subprocess.Popen( ['/var/lib/heat-cfntools/cfn-userdata'], stderr=mox.IgnoreArg(), stdout=mox.IgnoreArg()).AndReturn(FakePOpen(0)) self.m.ReplayAll() loguserdata.main() self.m.VerifyAll() def test_main_script_empty(self): pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.7.0')) os.chmod('/var/lib/heat-cfntools/cfn-userdata', 0o700).AndReturn(None) subprocess.Popen( ['/var/lib/heat-cfntools/cfn-userdata'], stderr=mox.IgnoreArg(), stdout=mox.IgnoreArg()).AndRaise( OSError(errno.ENOEXEC, "empty script")) self.m.ReplayAll() self.assertIsNone(loguserdata.main()) self.m.VerifyAll() def test_main_os_error(self): pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.7.0')) os.chmod('/var/lib/heat-cfntools/cfn-userdata', 0o700).AndReturn(None) subprocess.Popen( ['/var/lib/heat-cfntools/cfn-userdata'], stderr=mox.IgnoreArg(), stdout=mox.IgnoreArg()).AndRaise( OSError(errno.ENOENT, "no such file")) self.m.ReplayAll() self.assertEqual(os.EX_OSERR, loguserdata.main()) self.m.VerifyAll() def test_main_error_other(self): pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.7.0')) os.chmod('/var/lib/heat-cfntools/cfn-userdata', 0o700).AndReturn(None) subprocess.Popen( ['/var/lib/heat-cfntools/cfn-userdata'], stderr=mox.IgnoreArg(), stdout=mox.IgnoreArg()).AndRaise(IOError("read failed")) self.m.ReplayAll() self.assertEqual(os.EX_SOFTWARE, loguserdata.main()) self.m.VerifyAll() def test_main_fails(self): #fail on ci version pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.5.0')) #fail on execute cfn-userdata pkg_resources.get_distribution('cloud-init').AndReturn( FakeCiVersion('0.7.0')) os.chmod('/var/lib/heat-cfntools/cfn-userdata', 0o700).AndReturn(None) subprocess.Popen( ['/var/lib/heat-cfntools/cfn-userdata'], stderr=mox.IgnoreArg(), stdout=mox.IgnoreArg()).AndReturn(FakePOpen(-2)) self.m.ReplayAll() self.assertEqual(-1, loguserdata.main()) self.assertEqual(-2, loguserdata.main()) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_api_openstack_v1.py0000664000567000056700000044224512540642614022766 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. import json import mock from oslo.config import cfg import webob.exc import heat.api.middleware.fault as fault import heat.api.openstack.v1 as api_v1 import heat.api.openstack.v1.actions as actions import heat.api.openstack.v1.build_info as build_info import heat.api.openstack.v1.events as events import heat.api.openstack.v1.resources as resources import heat.api.openstack.v1.software_configs as software_configs import heat.api.openstack.v1.software_deployments as software_deployments import heat.api.openstack.v1.stacks as stacks from heat.common import exception as heat_exc from heat.common import identifier from heat.common import policy from heat.common import urlfetch from heat.common.wsgi import Request from heat.openstack.common import rpc from heat.openstack.common.rpc import common as rpc_common from heat.rpc import api as rpc_api from heat.rpc import client as rpc_client from heat.tests.common import HeatTestCase from heat.tests import utils def request_with_middleware(middleware, func, req, *args, **kwargs): @webob.dec.wsgify def _app(req): return func(req, *args, **kwargs) resp = middleware(_app).process_request(req) return resp def to_remote_error(error): """Converts the given exception to the one with the _Remote suffix. """ exc_info = (type(error), error, None) serialized = rpc_common.serialize_remote_exception(exc_info) remote_error = rpc_common.deserialize_remote_exception(cfg.CONF, serialized) return remote_error class InstantiationDataTest(HeatTestCase): def test_format_parse(self): data = {"AWSTemplateFormatVersion": "2010-09-09", "key1": ["val1[0]", "val1[1]"], "key2": "val2"} json_repr = '{"AWSTemplateFormatVersion" : "2010-09-09",' \ '"key1": [ "val1[0]", "val1[1]" ], ' \ '"key2": "val2" }' parsed = stacks.InstantiationData.format_parse(json_repr, 'foo') self.assertEqual(data, parsed) def test_format_parse_invalid(self): self.assertRaises(webob.exc.HTTPBadRequest, stacks.InstantiationData.format_parse, '!@#$%^¬ json', 'Garbage') def test_format_parse_invalid_message(self): # make sure the parser error gets through to the caller. bad_temp = ''' heat_template_version: '2013-05-23' parameters: KeyName: type: string description: bla ''' parse_ex = self.assertRaises(webob.exc.HTTPBadRequest, stacks.InstantiationData.format_parse, bad_temp, 'foo') self.assertIn('line 4, column 3', str(parse_ex)) def test_stack_name(self): body = {'stack_name': 'wibble'} data = stacks.InstantiationData(body) self.assertEqual('wibble', data.stack_name()) def test_stack_name_missing(self): body = {'not the stack_name': 'wibble'} data = stacks.InstantiationData(body) self.assertRaises(webob.exc.HTTPBadRequest, data.stack_name) def test_template_inline(self): template = {'foo': 'bar', 'blarg': 'wibble'} body = {'template': template} data = stacks.InstantiationData(body) self.assertEqual(template, data.template()) def test_template_string_json(self): template = '{"heat_template_version": "2013-05-23",' \ '"foo": "bar", "blarg": "wibble"}' body = {'template': template} data = stacks.InstantiationData(body) self.assertEqual(json.loads(template), data.template()) def test_template_string_yaml(self): template = '''HeatTemplateFormatVersion: 2012-12-12 foo: bar blarg: wibble ''' parsed = {u'HeatTemplateFormatVersion': u'2012-12-12', u'blarg': u'wibble', u'foo': u'bar'} body = {'template': template} data = stacks.InstantiationData(body) self.assertEqual(parsed, data.template()) def test_template_url(self): template = {'heat_template_version': '2013-05-23', 'foo': 'bar', 'blarg': 'wibble'} url = 'http://example.com/template' body = {'template_url': url} data = stacks.InstantiationData(body) self.m.StubOutWithMock(urlfetch, 'get') urlfetch.get(url).AndReturn(json.dumps(template)) self.m.ReplayAll() self.assertEqual(template, data.template()) self.m.VerifyAll() def test_template_priority(self): template = {'foo': 'bar', 'blarg': 'wibble'} url = 'http://example.com/template' body = {'template': template, 'template_url': url} data = stacks.InstantiationData(body) self.m.StubOutWithMock(urlfetch, 'get') self.m.ReplayAll() self.assertEqual(template, data.template()) self.m.VerifyAll() def test_template_missing(self): template = {'foo': 'bar', 'blarg': 'wibble'} body = {'not the template': template} data = stacks.InstantiationData(body) self.assertRaises(webob.exc.HTTPBadRequest, data.template) def test_parameters(self): params = {'foo': 'bar', 'blarg': 'wibble'} body = {'parameters': params, 'resource_registry': {}} data = stacks.InstantiationData(body) self.assertEqual(body, data.environment()) def test_environment_only_params(self): env = {'parameters': {'foo': 'bar', 'blarg': 'wibble'}} body = {'environment': env} data = stacks.InstantiationData(body) self.assertEqual(env, data.environment()) def test_environment_and_parameters(self): body = {'parameters': {'foo': 'bar'}, 'environment': {'parameters': {'blarg': 'wibble'}}} expect = {'parameters': {'blarg': 'wibble', 'foo': 'bar'}, 'resource_registry': {}} data = stacks.InstantiationData(body) self.assertEqual(expect, data.environment()) def test_parameters_override_environment(self): # This tests that the cli parameters will override # any parameters in the environment. body = {'parameters': {'foo': 'bar', 'tester': 'Yes'}, 'environment': {'parameters': {'blarg': 'wibble', 'tester': 'fail'}}} expect = {'parameters': {'blarg': 'wibble', 'foo': 'bar', 'tester': 'Yes'}, 'resource_registry': {}} data = stacks.InstantiationData(body) self.assertEqual(expect, data.environment()) def test_environment_bad_format(self): env = {'somethingnotsupported': {'blarg': 'wibble'}} body = {'environment': json.dumps(env)} data = stacks.InstantiationData(body) self.assertRaises(webob.exc.HTTPBadRequest, data.environment) def test_environment_missing(self): env = {'foo': 'bar', 'blarg': 'wibble'} body = {'not the environment': env} data = stacks.InstantiationData(body) self.assertEqual({'parameters': {}, 'resource_registry': {}}, data.environment()) def test_args(self): body = { 'parameters': {}, 'environment': {}, 'stack_name': 'foo', 'template': {}, 'template_url': 'http://example.com/', 'timeout_mins': 60, } data = stacks.InstantiationData(body) self.assertEqual({'timeout_mins': 60}, data.args()) class ControllerTest(object): """ Common utilities for testing API Controllers. """ def __init__(self, *args, **kwargs): super(ControllerTest, self).__init__(*args, **kwargs) cfg.CONF.set_default('host', 'server.test') self.topic = rpc_api.ENGINE_TOPIC self.api_version = '1.0' self.tenant = 't' self.mock_enforce = None def _environ(self, path): return { 'SERVER_NAME': 'server.test', 'SERVER_PORT': 8004, 'SCRIPT_NAME': '/v1', 'PATH_INFO': '/%s' % self.tenant + path, 'wsgi.url_scheme': 'http', } def _simple_request(self, path, params=None, method='GET'): environ = self._environ(path) environ['REQUEST_METHOD'] = method if params: qs = "&".join(["=".join([k, str(params[k])]) for k in params]) environ['QUERY_STRING'] = qs req = Request(environ) req.context = utils.dummy_context('api_test_user', self.tenant) self.context = req.context return req def _get(self, path, params=None): return self._simple_request(path, params=params) def _delete(self, path): return self._simple_request(path, method='DELETE') def _abandon(self, path): return self._simple_request(path, method='DELETE') def _data_request(self, path, data, content_type='application/json', method='POST'): environ = self._environ(path) environ['REQUEST_METHOD'] = method req = Request(environ) req.context = utils.dummy_context('api_test_user', self.tenant) self.context = req.context req.body = data return req def _post(self, path, data, content_type='application/json'): return self._data_request(path, data, content_type) def _put(self, path, data, content_type='application/json'): return self._data_request(path, data, content_type, method='PUT') def _url(self, id): host = 'server.test:8004' path = '/v1/%(tenant)s/stacks/%(stack_name)s/%(stack_id)s%(path)s' % id return 'http://%s%s' % (host, path) def tearDown(self): # Common tearDown to assert that policy enforcement happens for all # controller actions if self.mock_enforce: self.mock_enforce.assert_called_with( action=self.action, context=self.context, scope=self.controller.REQUEST_SCOPE) self.assertEqual(self.expected_request_count, len(self.mock_enforce.call_args_list)) super(ControllerTest, self).tearDown() def _mock_enforce_setup(self, mocker, action, allowed=True, expected_request_count=1): self.mock_enforce = mocker self.action = action self.mock_enforce.return_value = allowed self.expected_request_count = expected_request_count @mock.patch.object(policy.Enforcer, 'enforce') class StackControllerTest(ControllerTest, HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def setUp(self): super(StackControllerTest, self).setUp() # Create WSGI controller instance class DummyConfig(): bind_port = 8004 cfgopts = DummyConfig() self.controller = stacks.StackController(options=cfgopts) @mock.patch.object(rpc, 'call') def test_index(self, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) req = self._get('/stacks') identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') engine_resp = [ { u'stack_identity': dict(identity), u'updated_time': u'2012-07-09T09:13:11Z', u'template_description': u'blah', u'description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': identity.stack_name, u'stack_action': u'CREATE', u'stack_status': u'COMPLETE', u'parameters': {}, u'outputs': [], u'notification_topics': [], u'capabilities': [], u'disable_rollback': True, u'timeout_mins': 60, } ] mock_call.return_value = engine_resp result = self.controller.index(req, tenant_id=identity.tenant) expected = { 'stacks': [ { 'links': [{"href": self._url(identity), "rel": "self"}], 'id': '1', u'updated_time': u'2012-07-09T09:13:11Z', u'description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': u'wordpress', u'stack_status': u'CREATE_COMPLETE' } ] } self.assertEqual(expected, result) default_args = {'limit': None, 'sort_keys': None, 'marker': None, 'sort_dir': None, 'filters': None, 'tenant_safe': True} mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': default_args, 'version': self.api_version}, None) @mock.patch.object(rpc, 'call') def test_index_whitelists_pagination_params(self, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) params = { 'limit': 'fake limit', 'sort_keys': 'fake sort keys', 'marker': 'fake marker', 'sort_dir': 'fake sort dir', 'balrog': 'you shall not pass!' } req = self._get('/stacks', params=params) mock_call.return_value = [] self.controller.index(req, tenant_id=self.tenant) rpc_call_args, _ = mock_call.call_args engine_args = rpc_call_args[2]['args'] self.assertEqual(6, len(engine_args)) self.assertIn('limit', engine_args) self.assertIn('sort_keys', engine_args) self.assertIn('marker', engine_args) self.assertIn('sort_dir', engine_args) self.assertIn('filters', engine_args) self.assertIn('tenant_safe', engine_args) self.assertNotIn('balrog', engine_args) @mock.patch.object(rpc, 'call') def test_index_whitelist_filter_params(self, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) params = { 'status': 'fake status', 'name': 'fake name', 'balrog': 'you shall not pass!' } req = self._get('/stacks', params=params) mock_call.return_value = [] self.controller.index(req, tenant_id=self.tenant) rpc_call_args, _ = mock_call.call_args engine_args = rpc_call_args[2]['args'] self.assertIn('filters', engine_args) filters = engine_args['filters'] self.assertEqual(2, len(filters)) self.assertIn('status', filters) self.assertIn('name', filters) self.assertNotIn('balrog', filters) def test_index_returns_stack_count_if_with_count_is_true( self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) params = {'with_count': 'True'} req = self._get('/stacks', params=params) engine = self.controller.rpc_client engine.list_stacks = mock.Mock(return_value=[]) engine.count_stacks = mock.Mock(return_value=0) result = self.controller.index(req, tenant_id=self.tenant) self.assertEqual(0, result['count']) def test_index_doesnt_return_stack_count_if_with_count_is_falsy( self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) params = {'with_count': ''} req = self._get('/stacks', params=params) engine = self.controller.rpc_client engine.list_stacks = mock.Mock(return_value=[]) engine.count_stacks = mock.Mock() result = self.controller.index(req, tenant_id=self.tenant) self.assertNotIn('count', result) assert not engine.count_stacks.called @mock.patch.object(rpc_client.EngineClient, 'count_stacks') def test_index_doesnt_break_with_old_engine(self, mock_count_stacks, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) params = {'with_count': 'Truthy'} req = self._get('/stacks', params=params) engine = self.controller.rpc_client engine.list_stacks = mock.Mock(return_value=[]) mock_count_stacks.side_effect = AttributeError("Should not exist") result = self.controller.index(req, tenant_id=self.tenant) self.assertNotIn('count', result) def test_index_enforces_global_index_if_global_tenant(self, mock_enforce): params = {'global_tenant': 'True'} req = self._get('/stacks', params=params) rpc_client = self.controller.rpc_client rpc_client.list_stacks = mock.Mock(return_value=[]) rpc_client.count_stacks = mock.Mock() self.controller.index(req, tenant_id=self.tenant) mock_enforce.assert_called_with(action='global_index', scope=self.controller.REQUEST_SCOPE, context=self.context) def test_global_index_sets_tenant_safe_to_false(self, mock_enforce): rpc_client = self.controller.rpc_client rpc_client.list_stacks = mock.Mock(return_value=[]) rpc_client.count_stacks = mock.Mock() params = {'global_tenant': 'True'} req = self._get('/stacks', params=params) self.controller.index(req, tenant_id=self.tenant) rpc_client.list_stacks.assert_called_once_with(mock.ANY, filters=mock.ANY, tenant_safe=False) @mock.patch.object(rpc, 'call') def test_detail(self, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'detail', True) req = self._get('/stacks/detail') identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') engine_resp = [ { u'stack_identity': dict(identity), u'updated_time': u'2012-07-09T09:13:11Z', u'template_description': u'blah', u'description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': identity.stack_name, u'stack_action': u'CREATE', u'stack_status': u'COMPLETE', u'parameters': {'foo': 'bar'}, u'outputs': ['key', 'value'], u'notification_topics': [], u'capabilities': [], u'disable_rollback': True, u'timeout_mins': 60, } ] mock_call.return_value = engine_resp result = self.controller.detail(req, tenant_id=identity.tenant) expected = { 'stacks': [ { 'links': [{"href": self._url(identity), "rel": "self"}], 'id': '1', u'updated_time': u'2012-07-09T09:13:11Z', u'template_description': u'blah', u'description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': identity.stack_name, u'stack_status': u'CREATE_COMPLETE', u'parameters': {'foo': 'bar'}, u'outputs': ['key', 'value'], u'notification_topics': [], u'capabilities': [], u'disable_rollback': True, u'timeout_mins': 60, } ] } self.assertEqual(expected, result) default_args = {'limit': None, 'sort_keys': None, 'marker': None, 'sort_dir': None, 'filters': None, 'tenant_safe': True} mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': default_args, 'version': self.api_version}, None) @mock.patch.object(rpc, 'call') def test_index_rmt_aterr(self, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) req = self._get('/stacks') mock_call.side_effect = to_remote_error(AttributeError()) resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant) self.assertEqual(400, resp.json['code']) self.assertEqual('AttributeError', resp.json['error']['type']) mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': mock.ANY, 'version': self.api_version}, None) def test_index_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', False) req = self._get('/stacks') resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) @mock.patch.object(rpc, 'call') def test_index_rmt_interr(self, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) req = self._get('/stacks') mock_call.side_effect = to_remote_error(Exception()) resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant) self.assertEqual(500, resp.json['code']) self.assertEqual('Exception', resp.json['error']['type']) mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': mock.ANY, 'version': self.api_version}, None) def test_create(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'stack_name': identity.stack_name, 'parameters': parameters, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': identity.stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndReturn(dict(identity)) self.m.ReplayAll() response = self.controller.create(req, tenant_id=identity.tenant, body=body) expected = {'stack': {'id': '1', 'links': [{'href': self._url(identity), 'rel': 'self'}]}} self.assertEqual(expected, response) self.m.VerifyAll() def test_create_with_files(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'stack_name': identity.stack_name, 'parameters': parameters, 'files': {'my.yaml': 'This is the file contents.'}, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': identity.stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {'my.yaml': 'This is the file contents.'}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndReturn(dict(identity)) self.m.ReplayAll() result = self.controller.create(req, tenant_id=identity.tenant, body=body) expected = {'stack': {'id': '1', 'links': [{'href': self._url(identity), 'rel': 'self'}]}} self.assertEqual(expected, result) self.m.VerifyAll() def test_create_err_rpcerr(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True, 3) stack_name = "wordpress" template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'stack_name': stack_name, 'parameters': parameters, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) unknown_parameter = heat_exc.UnknownUserParameter(key='a') missing_parameter = heat_exc.UserParameterMissing(key='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndRaise(to_remote_error(AttributeError())) rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndRaise(to_remote_error(unknown_parameter)) rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndRaise(to_remote_error(missing_parameter)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) self.assertEqual(400, resp.json['code']) self.assertEqual('AttributeError', resp.json['error']['type']) resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) self.assertEqual(400, resp.json['code']) self.assertEqual('UnknownUserParameter', resp.json['error']['type']) resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) self.assertEqual(400, resp.json['code']) self.assertEqual('UserParameterMissing', resp.json['error']['type']) self.m.VerifyAll() def test_create_err_existing(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) stack_name = "wordpress" template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'stack_name': stack_name, 'parameters': parameters, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) error = heat_exc.StackExists(stack_name='s') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) self.assertEqual(409, resp.json['code']) self.assertEqual('StackExists', resp.json['error']['type']) self.m.VerifyAll() def test_create_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', False) stack_name = "wordpress" template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'stack_name': stack_name, 'parameters': parameters, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_create_err_engine(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) stack_name = "wordpress" template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'stack_name': stack_name, 'parameters': parameters, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) error = heat_exc.StackValidationFailed(message='') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) self.assertEqual(400, resp.json['code']) self.assertEqual('StackValidationFailed', resp.json['error']['type']) self.m.VerifyAll() def test_create_err_stack_bad_reqest(self, mock_enforce): cfg.CONF.set_override('debug', True) template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'parameters': parameters, 'timeout_mins': 30} req = self._post('/stacks', json.dumps(body)) error = heat_exc.HTTPExceptionDisguise(webob.exc.HTTPBadRequest()) self.controller.create = mock.MagicMock(side_effect=error) resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, body) # When HTTP disguised exceptions reach the fault app, they are # converted into regular responses, just like non-HTTP exceptions self.assertEqual(400, resp.json['code']) self.assertEqual('HTTPBadRequest', resp.json['error']['type']) self.assertIsNotNone(resp.json['error']['traceback']) @mock.patch.object(rpc, 'call') @mock.patch.object(stacks.stacks_view, 'format_stack') def test_preview_stack(self, mock_format, mock_call, mock_enforce): self._mock_enforce_setup(mock_enforce, 'preview', True) body = {'stack_name': 'foo', 'template': {}} req = self._get('/stacks/preview', params={}) mock_call.return_value = {} mock_format.return_value = 'formatted_stack' result = self.controller.preview(req, tenant_id=self.tenant, body=body) self.assertEqual({'stack': 'formatted_stack'}, result) def test_lookup(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') req = self._get('/stacks/%(stack_name)s' % identity) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': identity.stack_name}, 'version': self.api_version}, None).AndReturn(identity) self.m.ReplayAll() found = self.assertRaises( webob.exc.HTTPFound, self.controller.lookup, req, tenant_id=identity.tenant, stack_name=identity.stack_name) self.assertEqual(self._url(identity), found.location) self.m.VerifyAll() def test_lookup_arn(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') req = self._get('/stacks%s' % identity.arn_url_path()) self.m.ReplayAll() found = self.assertRaises( webob.exc.HTTPFound, self.controller.lookup, req, tenant_id=identity.tenant, stack_name=identity.arn()) self.assertEqual(self._url(identity), found.location) self.m.VerifyAll() def test_lookup_nonexistent(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', True) stack_name = 'wibble' req = self._get('/stacks/%(stack_name)s' % { 'stack_name': stack_name}) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.lookup, req, tenant_id=self.tenant, stack_name=stack_name) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_lookup_err_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', False) stack_name = 'wibble' req = self._get('/stacks/%(stack_name)s' % { 'stack_name': stack_name}) resp = request_with_middleware(fault.FaultWrapper, self.controller.lookup, req, tenant_id=self.tenant, stack_name=stack_name) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_lookup_resource(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') req = self._get('/stacks/%(stack_name)s/resources' % identity) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': identity.stack_name}, 'version': self.api_version}, None).AndReturn(identity) self.m.ReplayAll() found = self.assertRaises( webob.exc.HTTPFound, self.controller.lookup, req, tenant_id=identity.tenant, stack_name=identity.stack_name, path='resources') self.assertEqual(self._url(identity) + '/resources', found.location) self.m.VerifyAll() def test_lookup_resource_nonexistent(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', True) stack_name = 'wibble' req = self._get('/stacks/%(stack_name)s/resources' % { 'stack_name': stack_name}) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.lookup, req, tenant_id=self.tenant, stack_name=stack_name, path='resources') self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_lookup_resource_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'lookup', False) stack_name = 'wibble' req = self._get('/stacks/%(stack_name)s/resources' % { 'stack_name': stack_name}) resp = request_with_middleware(fault.FaultWrapper, self.controller.lookup, req, tenant_id=self.tenant, stack_name=stack_name, path='resources') self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_show(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s' % identity) parameters = {u'DBUsername': u'admin', u'LinuxDistribution': u'F17', u'InstanceType': u'm1.large', u'DBRootPassword': u'admin', u'DBPassword': u'admin', u'DBName': u'wordpress'} outputs = [{u'output_key': u'WebsiteURL', u'description': u'URL for Wordpress wiki', u'output_value': u'http://10.0.0.8/wordpress'}] engine_resp = [ { u'stack_identity': dict(identity), u'updated_time': u'2012-07-09T09:13:11Z', u'parameters': parameters, u'outputs': outputs, u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': identity.stack_name, u'notification_topics': [], u'stack_action': u'CREATE', u'stack_status': u'COMPLETE', u'description': u'blah', u'disable_rollback': True, u'timeout_mins':60, u'capabilities': [], } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.show(req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) expected = { 'stack': { 'links': [{"href": self._url(identity), "rel": "self"}], 'id': '6', u'updated_time': u'2012-07-09T09:13:11Z', u'parameters': parameters, u'outputs': outputs, u'description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': identity.stack_name, u'stack_status': u'CREATE_COMPLETE', u'capabilities': [], u'notification_topics': [], u'disable_rollback': True, u'timeout_mins': 60, } } self.assertEqual(expected, response) self.m.VerifyAll() def test_show_notfound(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s' % identity) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_invalidtenant(self, mock_enforce): identity = identifier.HeatIdentifier('wibble', 'wordpress', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s' % identity) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) self.m.VerifyAll() def test_show_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', False) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s' % identity) resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_get_template(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'template', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s' % identity) template = {u'Foo': u'bar'} self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'get_template', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndReturn(template) self.m.ReplayAll() response = self.controller.template(req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(template, response) self.m.VerifyAll() def test_get_template_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'template', False) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s/template' % identity) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.template, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) self.m.VerifyAll() def test_get_template_err_notfound(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'template', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._get('/stacks/%(stack_name)s/%(stack_id)s' % identity) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'get_template', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.template, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_update(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'update', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'parameters': parameters, 'files': {}, 'timeout_mins': 30} req = self._put('/stacks/%(stack_name)s/%(stack_id)s' % identity, json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'update_stack', 'args': {'stack_identity': dict(identity), 'template': template, 'params': {'parameters': parameters, 'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndReturn(dict(identity)) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPAccepted, self.controller.update, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id, body=body) self.m.VerifyAll() def test_update_bad_name(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'update', True) identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'parameters': parameters, 'files': {}, 'timeout_mins': 30} req = self._put('/stacks/%(stack_name)s/%(stack_id)s' % identity, json.dumps(body)) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'update_stack', 'args': {'stack_identity': dict(identity), 'template': template, 'params': {u'parameters': parameters, u'resource_registry': {}}, 'files': {}, 'args': {'timeout_mins': 30}}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.update, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id, body=body) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_update_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'update', False) identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') template = {u'Foo': u'bar'} parameters = {u'InstanceType': u'm1.xlarge'} body = {'template': template, 'parameters': parameters, 'files': {}, 'timeout_mins': 30} req = self._put('/stacks/%(stack_name)s/%(stack_id)s' % identity, json.dumps(body)) resp = request_with_middleware(fault.FaultWrapper, self.controller.update, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id, body=body) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_delete(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._delete('/stacks/%(stack_name)s/%(stack_id)s' % identity) self.m.StubOutWithMock(rpc, 'call') # Engine returns None when delete successful rpc.call(req.context, self.topic, {'namespace': None, 'method': 'delete_stack', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndReturn(None) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPNoContent, self.controller.delete, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.m.VerifyAll() def test_delete_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete', False) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._delete('/stacks/%(stack_name)s/%(stack_id)s' % identity) resp = request_with_middleware(fault.FaultWrapper, self.controller.delete, req, tenant_id=self.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_abandon(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'abandon', True) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._abandon('/stacks/%(stack_name)s/%(stack_id)s' % identity) self.m.StubOutWithMock(rpc, 'call') # Engine returns json data on abandon completion expected = {"name": "test", "id": "123"} rpc.call(req.context, self.topic, {'namespace': None, 'method': 'abandon_stack', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndReturn(expected) self.m.ReplayAll() ret = self.controller.abandon(req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(expected, ret) self.m.VerifyAll() def test_abandon_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'abandon', False) identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._abandon('/stacks/%(stack_name)s/%(stack_id)s' % identity) resp = request_with_middleware(fault.FaultWrapper, self.controller.abandon, req, tenant_id=self.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_delete_bad_name(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete', True) identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') req = self._delete('/stacks/%(stack_name)s/%(stack_id)s' % identity) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') # Engine returns None when delete successful rpc.call(req.context, self.topic, {'namespace': None, 'method': 'delete_stack', 'args': {'stack_identity': dict(identity)}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.delete, req, tenant_id=identity.tenant, stack_name=identity.stack_name, stack_id=identity.stack_id) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_validate_template(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'validate_template', True) template = {u'Foo': u'bar'} body = {'template': template} req = self._post('/validate', json.dumps(body)) engine_response = { u'Description': u'blah', u'Parameters': [ { u'NoEcho': u'false', u'ParameterKey': u'InstanceType', u'Description': u'Instance type' } ] } self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'validate_template', 'args': {'template': template, 'params': {'parameters': {}, 'resource_registry': {}}}, 'version': self.api_version}, None).AndReturn(engine_response) self.m.ReplayAll() response = self.controller.validate_template(req, tenant_id=self.tenant, body=body) self.assertEqual(engine_response, response) self.m.VerifyAll() def test_validate_template_error(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'validate_template', True) template = {u'Foo': u'bar'} body = {'template': template} req = self._post('/validate', json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'validate_template', 'args': {'template': template, 'params': {'parameters': {}, 'resource_registry': {}}}, 'version': self.api_version}, None).AndReturn({'Error': 'fubar'}) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPBadRequest, self.controller.validate_template, req, tenant_id=self.tenant, body=body) self.m.VerifyAll() def test_validate_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'validate_template', False) template = {u'Foo': u'bar'} body = {'template': template} req = self._post('/validate', json.dumps(body)) resp = request_with_middleware(fault.FaultWrapper, self.controller.validate_template, req, tenant_id=self.tenant, body=body) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_list_resource_types(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'list_resource_types', True) req = self._get('/resource_types') engine_response = ['AWS::EC2::Instance', 'AWS::EC2::EIP', 'AWS::EC2::EIPAssociation'] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_resource_types', 'args': {'support_status': None}, 'version': '1.1'}, None).AndReturn(engine_response) self.m.ReplayAll() response = self.controller.list_resource_types(req, tenant_id=self.tenant) self.assertEqual({'resource_types': engine_response}, response) self.m.VerifyAll() def test_list_resource_types_error(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'list_resource_types', True) req = self._get('/resource_types') error = heat_exc.ResourceTypeNotFound(type_name='') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_resource_types', 'args': {'support_status': None}, 'version': '1.1'}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.list_resource_types, req, tenant_id=self.tenant) self.assertEqual(404, resp.json['code']) self.assertEqual('ResourceTypeNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_list_resource_types_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'list_resource_types', False) req = self._get('/resource_types') resp = request_with_middleware(fault.FaultWrapper, self.controller.list_resource_types, req, tenant_id=self.tenant) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_resource_schema(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'resource_schema', True) req = self._get('/resource_types/ResourceWithProps') type_name = 'ResourceWithProps' engine_response = { 'resource_type': type_name, 'properties': { 'Foo': {'type': 'string', 'required': False}, }, 'attributes': { 'foo': {'description': 'A generic attribute'}, 'Foo': {'description': 'Another generic attribute'}, }, } self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'resource_schema', 'args': {'type_name': type_name}, 'version': self.api_version}, None).AndReturn(engine_response) self.m.ReplayAll() response = self.controller.resource_schema(req, tenant_id=self.tenant, type_name=type_name) self.assertEqual(engine_response, response) self.m.VerifyAll() def test_resource_schema_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'resource_schema', True) req = self._get('/resource_types/BogusResourceType') type_name = 'BogusResourceType' error = heat_exc.ResourceTypeNotFound(type_name='BogusResourceType') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'resource_schema', 'args': {'type_name': type_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.resource_schema, req, tenant_id=self.tenant, type_name=type_name) self.assertEqual(404, resp.json['code']) self.assertEqual('ResourceTypeNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_resource_schema_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'resource_schema', False) req = self._get('/resource_types/BogusResourceType') type_name = 'BogusResourceType' resp = request_with_middleware(fault.FaultWrapper, self.controller.resource_schema, req, tenant_id=self.tenant, type_name=type_name) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_generate_template(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'generate_template', True) req = self._get('/resource_types/TEST_TYPE/template') engine_response = {'Type': 'TEST_TYPE'} self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'generate_template', 'args': {'type_name': 'TEST_TYPE'}, 'version': self.api_version}, None).AndReturn(engine_response) self.m.ReplayAll() self.controller.generate_template(req, tenant_id=self.tenant, type_name='TEST_TYPE') self.m.VerifyAll() def test_generate_template_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'generate_template', True) req = self._get('/resource_types/NOT_FOUND/template') error = heat_exc.ResourceTypeNotFound(type_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'generate_template', 'args': {'type_name': 'NOT_FOUND'}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.generate_template, req, tenant_id=self.tenant, type_name='NOT_FOUND') self.assertEqual(404, resp.json['code']) self.assertEqual('ResourceTypeNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_generate_template_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'generate_template', False) req = self._get('/resource_types/NOT_FOUND/template') resp = request_with_middleware(fault.FaultWrapper, self.controller.generate_template, req, tenant_id=self.tenant, type_name='blah') self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) class StackSerializerTest(HeatTestCase): def setUp(self): super(StackSerializerTest, self).setUp() self.serializer = stacks.StackSerializer() def test_serialize_create(self): result = {'stack': {'id': '1', 'links': [{'href': 'location', "rel": "self"}]}} response = webob.Response() response = self.serializer.create(response, result) self.assertEqual(201, response.status_int) self.assertEqual('location', response.headers['Location']) self.assertEqual('application/json', response.headers['Content-Type']) @mock.patch.object(policy.Enforcer, 'enforce') class ResourceControllerTest(ControllerTest, HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def setUp(self): super(ResourceControllerTest, self).setUp() # Create WSGI controller instance class DummyConfig(): bind_port = 8004 cfgopts = DummyConfig() self.controller = resources.ResourceController(options=cfgopts) def test_index(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(stack_identity._tenant_path() + '/resources') engine_resp = [ { u'resource_identity': dict(res_identity), u'stack_name': stack_identity.stack_name, u'resource_name': res_name, u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': stack_identity, u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_stack_resources', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.index(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) expected = { 'resources': [{'links': [{'href': self._url(res_identity), 'rel': 'self'}, {'href': self._url(stack_identity), 'rel': 'stack'}], u'resource_name': res_name, u'logical_resource_id': res_name, u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'resource_status': u'CREATE_COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance'}]} self.assertEqual(expected, result) self.m.VerifyAll() def test_index_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'rubbish', '1') req = self._get(stack_identity._tenant_path() + '/resources') error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_stack_resources', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_index_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', False) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(stack_identity._tenant_path() + '/resources') resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_show(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(stack_identity._tenant_path()) engine_resp = { u'description': u'', u'resource_identity': dict(res_identity), u'stack_name': stack_identity.stack_name, u'resource_name': res_name, u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': dict(stack_identity), u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', u'metadata': {u'ensureRunning': u'true'} } self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.show(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) expected = { 'resource': { 'links': [ {'href': self._url(res_identity), 'rel': 'self'}, {'href': self._url(stack_identity), 'rel': 'stack'}, ], u'description': u'', u'resource_name': res_name, u'logical_resource_id': res_name, u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'resource_status': u'CREATE_COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', } } self.assertEqual(expected, result) self.m.VerifyAll() def test_show_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'rubbish', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path()) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_nonexist_resource(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) res_name = 'Wibble' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path()) error = heat_exc.ResourceNotFound(stack_name='a', resource_name='b') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(404, resp.json['code']) self.assertEqual('ResourceNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_uncreated_resource(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path()) error = heat_exc.ResourceNotAvailable(resource_name='') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(404, resp.json['code']) self.assertEqual('ResourceNotAvailable', resp.json['error']['type']) self.m.VerifyAll() def test_show_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', False) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path()) resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_metadata_show(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'metadata', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(stack_identity._tenant_path()) engine_resp = { u'description': u'', u'resource_identity': dict(res_identity), u'stack_name': stack_identity.stack_name, u'resource_name': res_name, u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': dict(stack_identity), u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', u'metadata': {u'ensureRunning': u'true'} } self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.metadata(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) expected = {'metadata': {u'ensureRunning': u'true'}} self.assertEqual(expected, result) self.m.VerifyAll() def test_metadata_show_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'metadata', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'rubbish', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path() + '/metadata') error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.metadata, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_metadata_show_nonexist_resource(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'metadata', True) res_name = 'wibble' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path() + '/metadata') error = heat_exc.ResourceNotFound(stack_name='a', resource_name='b') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': {'stack_identity': stack_identity, 'resource_name': res_name}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.metadata, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(404, resp.json['code']) self.assertEqual('ResourceNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_metadata_show_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'metadata', False) res_name = 'wibble' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) req = self._get(res_identity._tenant_path() + '/metadata') resp = request_with_middleware(fault.FaultWrapper, self.controller.metadata, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_signal(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'signal', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') req = self._get(stack_identity._tenant_path()) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'resource_signal', 'args': {'stack_identity': stack_identity, 'resource_name': res_name, 'details': 'Signal content'}, 'version': self.api_version}, None) self.m.ReplayAll() result = self.controller.signal(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name, body="Signal content") self.assertIsNone(result) self.m.VerifyAll() @mock.patch.object(policy.Enforcer, 'enforce') class EventControllerTest(ControllerTest, HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def setUp(self): super(EventControllerTest, self).setUp() # Create WSGI controller instance class DummyConfig(): bind_port = 8004 cfgopts = DummyConfig() self.controller = events.EventController(options=cfgopts) def test_resource_index_event_id_integer(self, mock_enforce): self._test_resource_index('42', mock_enforce) def test_resource_index_event_id_uuid(self, mock_enforce): self._test_resource_index('a3455d8c-9f88-404d-a85b-5315293e67de', mock_enforce) def _test_resource_index(self, event_id, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) ev_identity = identifier.EventIdentifier(event_id=event_id, **res_identity) req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events') engine_resp = [ { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': res_name, u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', }, { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': 'SomeOtherResource', u'logical_resource_id': 'SomeOtherResource', u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.index(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) expected = { 'events': [ { 'id': event_id, 'links': [ {'href': self._url(ev_identity), 'rel': 'self'}, {'href': self._url(res_identity), 'rel': 'resource'}, {'href': self._url(stack_identity), 'rel': 'stack'}, ], u'resource_name': res_name, u'logical_resource_id': res_name, u'resource_status_reason': u'state changed', u'event_time': u'2012-07-23T13:05:39Z', u'resource_status': u'CREATE_IN_PROGRESS', u'physical_resource_id': None, } ] } self.assertEqual(expected, result) self.m.VerifyAll() def test_stack_index_event_id_integer(self, mock_enforce): self._test_stack_index('42', mock_enforce) def test_stack_index_event_id_uuid(self, mock_enforce): self._test_stack_index('a3455d8c-9f88-404d-a85b-5315293e67de', mock_enforce) def _test_stack_index(self, event_id, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) ev_identity = identifier.EventIdentifier(event_id=event_id, **res_identity) req = self._get(stack_identity._tenant_path() + '/events') engine_resp = [ { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': res_name, u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.index(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) expected = { 'events': [ { 'id': event_id, 'links': [ {'href': self._url(ev_identity), 'rel': 'self'}, {'href': self._url(res_identity), 'rel': 'resource'}, {'href': self._url(stack_identity), 'rel': 'stack'}, ], u'resource_name': res_name, u'logical_resource_id': res_name, u'resource_status_reason': u'state changed', u'event_time': u'2012-07-23T13:05:39Z', u'resource_status': u'CREATE_IN_PROGRESS', u'physical_resource_id': None, } ] } self.assertEqual(expected, result) self.m.VerifyAll() def test_index_stack_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') req = self._get(stack_identity._tenant_path() + '/events') error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_index_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', False) stack_identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') req = self._get(stack_identity._tenant_path() + '/events') resp = request_with_middleware(fault.FaultWrapper, self.controller.index, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_index_resource_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) event_id = '42' res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) ev_identity = identifier.EventIdentifier(event_id=event_id, **res_identity) req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events') engine_resp = [ { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': 'SomeOtherResource', u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPNotFound, self.controller.index, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name) self.m.VerifyAll() def test_show_event_id_integer(self, mock_enforce): self._test_show('42', mock_enforce) def test_show_event_id_uuid(self, mock_enforce): self._test_show('a3455d8c-9f88-404d-a85b-5315293e67de', mock_enforce) def _test_show(self, event_id, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) ev1_identity = identifier.EventIdentifier(event_id='41', **res_identity) ev_identity = identifier.EventIdentifier(event_id=event_id, **res_identity) req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events/' + event_id) engine_resp = [ { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': res_name, u'resource_status_reason': u'state changed', u'event_identity': dict(ev1_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', }, { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:06:00Z', u'stack_identity': dict(stack_identity), u'resource_name': res_name, u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.show(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name, event_id=event_id) expected = { 'event': { 'id': event_id, 'links': [ {'href': self._url(ev_identity), 'rel': 'self'}, {'href': self._url(res_identity), 'rel': 'resource'}, {'href': self._url(stack_identity), 'rel': 'stack'}, ], u'resource_name': res_name, u'logical_resource_id': res_name, u'resource_status_reason': u'state changed', u'event_time': u'2012-07-23T13:06:00Z', u'resource_status': u'CREATE_COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', u'resource_properties': {u'UserData': u'blah'}, } } self.assertEqual(expected, result) self.m.VerifyAll() def test_show_nonexist_event_id_integer(self, mock_enforce): self._test_show_nonexist('42', '41', mock_enforce) def test_show_nonexist_event_id_uuid(self, mock_enforce): self._test_show_nonexist('a3455d8c-9f88-404d-a85b-5315293e67de', 'x3455x8x-9x88-404x-x85x-5315293x67xx', mock_enforce) def _test_show_nonexist(self, event_id, search_event_id, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) ev_identity = identifier.EventIdentifier(event_id=search_event_id, **res_identity) req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events/' + event_id) engine_resp = [ { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': res_name, u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name, event_id=event_id) self.m.VerifyAll() def test_show_bad_resource(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) event_id = '42' res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6') res_identity = identifier.ResourceIdentifier(resource_name=res_name, **stack_identity) ev_identity = identifier.EventIdentifier(event_id='41', **res_identity) req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events/' + event_id) engine_resp = [ { u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': dict(stack_identity), u'resource_name': 'SomeOtherResourceName', u'resource_status_reason': u'state changed', u'event_identity': dict(ev_identity), u'resource_action': u'CREATE', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance', } ] self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name, event_id=event_id) self.m.VerifyAll() def test_show_stack_nonexist(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', True) event_id = '42' res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events/' + event_id) error = heat_exc.StackNotFound(stack_name='a') self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndRaise(to_remote_error(error)) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name, event_id=event_id) self.assertEqual(404, resp.json['code']) self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show', False) event_id = '42' res_name = 'WikiDatabase' stack_identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6') req = self._get(stack_identity._tenant_path() + '/resources/' + res_name + '/events/' + event_id) resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, resource_name=res_name, event_id=event_id) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) class RoutesTest(HeatTestCase): def assertRoute(self, mapper, path, method, action, controller, params={}): route = mapper.match(path, {'REQUEST_METHOD': method}) self.assertIsNotNone(route) self.assertEqual(action, route['action']) self.assertEqual( controller, route['controller'].controller.__class__.__name__) del(route['action']) del(route['controller']) self.assertEqual(params, route) def setUp(self): super(RoutesTest, self).setUp() self.m = api_v1.API({}).map def test_template_handling(self): self.assertRoute( self.m, '/aaaa/resource_types', 'GET', 'list_resource_types', 'StackController', { 'tenant_id': 'aaaa', }) self.assertRoute( self.m, '/aaaa/resource_types/test_type', 'GET', 'resource_schema', 'StackController', { 'tenant_id': 'aaaa', 'type_name': 'test_type' }) self.assertRoute( self.m, '/aaaa/resource_types/test_type/template', 'GET', 'generate_template', 'StackController', { 'tenant_id': 'aaaa', 'type_name': 'test_type' }) self.assertRoute( self.m, '/aaaa/validate', 'POST', 'validate_template', 'StackController', { 'tenant_id': 'aaaa' }) def test_stack_collection(self): self.assertRoute( self.m, '/aaaa/stacks', 'GET', 'index', 'StackController', { 'tenant_id': 'aaaa' }) self.assertRoute( self.m, '/aaaa/stacks', 'POST', 'create', 'StackController', { 'tenant_id': 'aaaa' }) self.assertRoute( self.m, '/aaaa/stacks/preview', 'POST', 'preview', 'StackController', { 'tenant_id': 'aaaa' }) self.assertRoute( self.m, '/aaaa/stacks/detail', 'GET', 'detail', 'StackController', { 'tenant_id': 'aaaa' }) def test_stack_data(self): self.assertRoute( self.m, '/aaaa/stacks/teststack', 'GET', 'lookup', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack' }) self.assertRoute( self.m, '/aaaa/stacks/arn:openstack:heat::6548ab64fbda49deb188851a3b7d8c8b' ':stacks/stack-1411-06/1c5d9bb2-3464-45e2-a728-26dfa4e1d34a', 'GET', 'lookup', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'arn:openstack:heat:' ':6548ab64fbda49deb188851a3b7d8c8b:stacks/stack-1411-06/' '1c5d9bb2-3464-45e2-a728-26dfa4e1d34a' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/resources', 'GET', 'lookup', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'path': 'resources' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/events', 'GET', 'lookup', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'path': 'events' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb', 'GET', 'show', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', }) def test_stack_data_template(self): self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/template', 'GET', 'template', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', }) self.assertRoute( self.m, '/aaaa/stacks/teststack/template', 'GET', 'lookup', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'path': 'template' }) def test_stack_post_actions(self): self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/actions', 'POST', 'action', 'ActionController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', }) def test_stack_post_actions_lookup_redirect(self): self.assertRoute( self.m, '/aaaa/stacks/teststack/actions', 'POST', 'lookup', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'path': 'actions' }) def test_stack_update_delete(self): self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb', 'PUT', 'update', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb', 'DELETE', 'delete', 'StackController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', }) def test_resources(self): self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/resources', 'GET', 'index', 'ResourceController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/resources/cccc', 'GET', 'show', 'ResourceController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', 'resource_name': 'cccc' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/resources/cccc/metadata', 'GET', 'metadata', 'ResourceController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', 'resource_name': 'cccc' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/resources/cccc/signal', 'POST', 'signal', 'ResourceController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', 'resource_name': 'cccc' }) def test_events(self): self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/events', 'GET', 'index', 'EventController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/resources/cccc/events', 'GET', 'index', 'EventController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', 'resource_name': 'cccc' }) self.assertRoute( self.m, '/aaaa/stacks/teststack/bbbb/resources/cccc/events/dddd', 'GET', 'show', 'EventController', { 'tenant_id': 'aaaa', 'stack_name': 'teststack', 'stack_id': 'bbbb', 'resource_name': 'cccc', 'event_id': 'dddd' }) def test_software_configs(self): self.assertRoute( self.m, '/aaaa/software_configs', 'POST', 'create', 'SoftwareConfigController', { 'tenant_id': 'aaaa' }) self.assertRoute( self.m, '/aaaa/software_configs/bbbb', 'GET', 'show', 'SoftwareConfigController', { 'tenant_id': 'aaaa', 'config_id': 'bbbb' }) self.assertRoute( self.m, '/aaaa/software_configs/bbbb', 'DELETE', 'delete', 'SoftwareConfigController', { 'tenant_id': 'aaaa', 'config_id': 'bbbb' }) def test_software_deployments(self): self.assertRoute( self.m, '/aaaa/software_deployments', 'GET', 'index', 'SoftwareDeploymentController', { 'tenant_id': 'aaaa' }) self.assertRoute( self.m, '/aaaa/software_deployments', 'POST', 'create', 'SoftwareDeploymentController', { 'tenant_id': 'aaaa' }) self.assertRoute( self.m, '/aaaa/software_deployments/bbbb', 'GET', 'show', 'SoftwareDeploymentController', { 'tenant_id': 'aaaa', 'deployment_id': 'bbbb' }) self.assertRoute( self.m, '/aaaa/software_deployments/bbbb', 'PUT', 'update', 'SoftwareDeploymentController', { 'tenant_id': 'aaaa', 'deployment_id': 'bbbb' }) self.assertRoute( self.m, '/aaaa/software_deployments/bbbb', 'DELETE', 'delete', 'SoftwareDeploymentController', { 'tenant_id': 'aaaa', 'deployment_id': 'bbbb' }) def test_build_info(self): self.assertRoute( self.m, '/fake_tenant/build_info', 'GET', 'build_info', 'BuildInfoController', {'tenant_id': 'fake_tenant'} ) @mock.patch.object(policy.Enforcer, 'enforce') class ActionControllerTest(ControllerTest, HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def setUp(self): super(ActionControllerTest, self).setUp() # Create WSGI controller instance class DummyConfig(): bind_port = 8004 cfgopts = DummyConfig() self.controller = actions.ActionController(options=cfgopts) def test_action_suspend(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'suspend': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'stack_suspend', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(None) self.m.ReplayAll() result = self.controller.action(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.assertIsNone(result) self.m.VerifyAll() def test_action_resume(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'resume': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'stack_resume', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndReturn(None) self.m.ReplayAll() result = self.controller.action(req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.assertIsNone(result) self.m.VerifyAll() def test_action_badaction(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'notallowed': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPBadRequest, self.controller.action, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.m.VerifyAll() def test_action_badaction_empty(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPBadRequest, self.controller.action, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.m.VerifyAll() def test_action_badaction_multiple(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'one': None, 'two': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.ReplayAll() self.assertRaises(webob.exc.HTTPBadRequest, self.controller.action, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.m.VerifyAll() def test_action_rmt_aterr(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'suspend': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.StubOutWithMock(rpc, 'call') rpc.call(req.context, self.topic, {'namespace': None, 'method': 'stack_suspend', 'args': {'stack_identity': stack_identity}, 'version': self.api_version}, None).AndRaise(to_remote_error(AttributeError())) self.m.ReplayAll() resp = request_with_middleware(fault.FaultWrapper, self.controller.action, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.assertEqual(400, resp.json['code']) self.assertEqual('AttributeError', resp.json['error']['type']) self.m.VerifyAll() def test_action_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', False) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'suspend': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) resp = request_with_middleware(fault.FaultWrapper, self.controller.action, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) def test_action_badaction_ise(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) stack_identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '1') body = {'oops': None} req = self._post(stack_identity._tenant_path() + '/actions', data=json.dumps(body)) self.m.ReplayAll() self.controller.ACTIONS = (SUSPEND, NEW) = ('suspend', 'oops') self.assertRaises(webob.exc.HTTPInternalServerError, self.controller.action, req, tenant_id=self.tenant, stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id, body=body) self.m.VerifyAll() @mock.patch.object(policy.Enforcer, 'enforce') class BuildInfoControllerTest(ControllerTest, HeatTestCase): def setUp(self): super(BuildInfoControllerTest, self).setUp() self.controller = build_info.BuildInfoController({}) def test_theres_a_default_api_build_revision(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'build_info', True) req = self._get('/build_info') self.controller.rpc_client = mock.Mock() response = self.controller.build_info(req, tenant_id=self.tenant) self.assertIn('api', response) self.assertIn('revision', response['api']) self.assertEqual('unknown', response['api']['revision']) @mock.patch.object(build_info.cfg, 'CONF') def test_response_api_build_revision_from_config_file( self, mock_conf, mock_enforce): self._mock_enforce_setup(mock_enforce, 'build_info', True) req = self._get('/build_info') mock_engine = mock.Mock() mock_engine.get_revision.return_value = 'engine_revision' self.controller.rpc_client = mock_engine mock_conf.revision = {'heat_revision': 'test'} response = self.controller.build_info(req, tenant_id=self.tenant) self.assertEqual('test', response['api']['revision']) def test_retrieves_build_revision_from_the_engine(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'build_info', True) req = self._get('/build_info') mock_engine = mock.Mock() mock_engine.get_revision.return_value = 'engine_revision' self.controller.rpc_client = mock_engine response = self.controller.build_info(req, tenant_id=self.tenant) self.assertIn('engine', response) self.assertIn('revision', response['engine']) self.assertEqual('engine_revision', response['engine']['revision']) def test_build_info_err_denied_policy(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'build_info', False) req = self._get('/build_info') resp = request_with_middleware(fault.FaultWrapper, self.controller.build_info, req, tenant_id=self.tenant) self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) class SoftwareConfigControllerTest(ControllerTest, HeatTestCase): def setUp(self): super(SoftwareConfigControllerTest, self).setUp() self.controller = software_configs.SoftwareConfigController({}) def test_default(self): self.assertRaises( webob.exc.HTTPNotFound, self.controller.default, None) @mock.patch.object(policy.Enforcer, 'enforce') def test_show(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show') config_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._get('/software_configs/%s' % config_id) return_value = { 'id': config_id, 'name': 'config_mysql', 'group': 'Heat::Shell', 'config': '#!/bin/bash', 'inputs': [], 'ouputs': [], 'options': []} expected = {'software_config': return_value} with mock.patch.object( self.controller.rpc_client, 'show_software_config', return_value=return_value): resp = self.controller.show( req, config_id=config_id, tenant_id=self.tenant) self.assertEqual(expected, resp) @mock.patch.object(policy.Enforcer, 'enforce') def test_show_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show') config_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._get('/software_configs/%s' % config_id) error = heat_exc.NotFound('Not found %s' % config_id) with mock.patch.object( self.controller.rpc_client, 'show_software_config', side_effect=to_remote_error(error)): resp = request_with_middleware(fault.FaultWrapper, self.controller.show, req, config_id=config_id, tenant_id=self.tenant) self.assertEqual(404, resp.json['code']) self.assertEqual('NotFound', resp.json['error']['type']) @mock.patch.object(policy.Enforcer, 'enforce') def test_create(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create') body = { 'name': 'config_mysql', 'group': 'Heat::Shell', 'config': '#!/bin/bash', 'inputs': [], 'ouputs': [], 'options': []} return_value = body.copy() config_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' return_value['id'] = config_id req = self._post('/software_configs', json.dumps(body)) expected = {'software_config': return_value} with mock.patch.object( self.controller.rpc_client, 'create_software_config', return_value=return_value): resp = self.controller.create( req, body=body, tenant_id=self.tenant) self.assertEqual(expected, resp) @mock.patch.object(policy.Enforcer, 'enforce') def test_delete(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete') config_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._delete('/software_configs/%s' % config_id) return_value = None with mock.patch.object( self.controller.rpc_client, 'delete_software_config', return_value=return_value): self.assertRaises( webob.exc.HTTPNoContent, self.controller.delete, req, config_id=config_id, tenant_id=self.tenant) @mock.patch.object(policy.Enforcer, 'enforce') def test_delete_error(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete') config_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._delete('/software_configs/%s' % config_id) error = Exception('something wrong') with mock.patch.object( self.controller.rpc_client, 'delete_software_config', side_effect=to_remote_error(error)): resp = request_with_middleware( fault.FaultWrapper, self.controller.delete, req, config_id=config_id, tenant_id=self.tenant) self.assertEqual(500, resp.json['code']) self.assertEqual('Exception', resp.json['error']['type']) @mock.patch.object(policy.Enforcer, 'enforce') def test_delete_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete') config_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._delete('/software_configs/%s' % config_id) error = heat_exc.NotFound('Not found %s' % config_id) with mock.patch.object( self.controller.rpc_client, 'delete_software_config', side_effect=to_remote_error(error)): resp = request_with_middleware( fault.FaultWrapper, self.controller.delete, req, config_id=config_id, tenant_id=self.tenant) self.assertEqual(404, resp.json['code']) self.assertEqual('NotFound', resp.json['error']['type']) class SoftwareDeploymentControllerTest(ControllerTest, HeatTestCase): def setUp(self): super(SoftwareDeploymentControllerTest, self).setUp() self.controller = software_deployments.SoftwareDeploymentController({}) def test_default(self): self.assertRaises( webob.exc.HTTPNotFound, self.controller.default, None) @mock.patch.object(policy.Enforcer, 'enforce') def test_index(self, mock_enforce): self._mock_enforce_setup( mock_enforce, 'index', expected_request_count=2) req = self._get('/software_deployments') return_value = [] with mock.patch.object( self.controller.rpc_client, 'list_software_deployments', return_value=return_value) as mock_call: resp = self.controller.index(req, tenant_id=self.tenant) self.assertEqual( {'software_deployments': []}, resp) whitelist = mock_call.call_args[1] self.assertEqual({}, whitelist) server_id = 'fb322564-7927-473d-8aad-68ae7fbf2abf' req = self._get('/software_deployments', {'server_id': server_id}) with mock.patch.object( self.controller.rpc_client, 'list_software_deployments', return_value=return_value) as mock_call: resp = self.controller.index(req, tenant_id=self.tenant) self.assertEqual( {'software_deployments': []}, resp) whitelist = mock_call.call_args[1] self.assertEqual({'server_id': server_id}, whitelist) @mock.patch.object(policy.Enforcer, 'enforce') def test_show(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show') deployment_id = '38eccf10-97e5-4ae8-9d37-b577c9801750' config_id = 'd00ba4aa-db33-42e1-92f4-2a6469260107' server_id = 'fb322564-7927-473d-8aad-68ae7fbf2abf' req = self._get('/software_deployments/%s' % deployment_id) return_value = { 'id': deployment_id, 'server_id': server_id, 'input_values': {}, 'output_values': {}, 'action': 'INIT', 'status': 'COMPLETE', 'status_reason': None, 'config_id': config_id, 'config': '#!/bin/bash', 'name': 'config_mysql', 'group': 'Heat::Shell', 'inputs': [], 'outputs': [], 'options': []} expected = {'software_deployment': return_value} with mock.patch.object( self.controller.rpc_client, 'show_software_deployment', return_value=return_value): resp = self.controller.show( req, deployment_id=config_id, tenant_id=self.tenant) self.assertEqual(expected, resp) @mock.patch.object(policy.Enforcer, 'enforce') def test_show_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'show') deployment_id = '38eccf10-97e5-4ae8-9d37-b577c9801750' req = self._get('/software_deployments/%s' % deployment_id) error = heat_exc.NotFound('Not found %s' % deployment_id) with mock.patch.object( self.controller.rpc_client, 'show_software_deployment', side_effect=to_remote_error(error)): resp = request_with_middleware( fault.FaultWrapper, self.controller.show, req, deployment_id=deployment_id, tenant_id=self.tenant) self.assertEqual(404, resp.json['code']) self.assertEqual('NotFound', resp.json['error']['type']) @mock.patch.object(policy.Enforcer, 'enforce') def test_create(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create') config_id = 'd00ba4aa-db33-42e1-92f4-2a6469260107' server_id = 'fb322564-7927-473d-8aad-68ae7fbf2abf' body = { 'server_id': server_id, 'input_values': {}, 'action': 'INIT', 'status': 'COMPLETE', 'status_reason': None, 'config_id': config_id} return_value = body.copy() deployment_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' return_value['id'] = deployment_id req = self._post('/software_deployments', json.dumps(body)) expected = {'software_deployment': return_value} with mock.patch.object( self.controller.rpc_client, 'create_software_deployment', return_value=return_value): resp = self.controller.create( req, body=body, tenant_id=self.tenant) self.assertEqual(expected, resp) @mock.patch.object(policy.Enforcer, 'enforce') def test_update(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'update') config_id = 'd00ba4aa-db33-42e1-92f4-2a6469260107' server_id = 'fb322564-7927-473d-8aad-68ae7fbf2abf' body = { 'input_values': {}, 'action': 'INIT', 'status': 'COMPLETE', 'status_reason': None, 'config_id': config_id} return_value = body.copy() deployment_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' return_value['id'] = deployment_id req = self._put('/software_deployments/%s' % deployment_id, json.dumps(body)) return_value['server_id'] = server_id expected = {'software_deployment': return_value} with mock.patch.object( self.controller.rpc_client, 'update_software_deployment', return_value=return_value): resp = self.controller.update( req, deployment_id=deployment_id, body=body, tenant_id=self.tenant) self.assertEqual(expected, resp) @mock.patch.object(policy.Enforcer, 'enforce') def test_update_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'update') deployment_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._put('/software_deployments/%s' % deployment_id, '{}') error = heat_exc.NotFound('Not found %s' % deployment_id) with mock.patch.object( self.controller.rpc_client, 'update_software_deployment', side_effect=to_remote_error(error)): resp = request_with_middleware( fault.FaultWrapper, self.controller.update, req, deployment_id=deployment_id, body={}, tenant_id=self.tenant) self.assertEqual(404, resp.json['code']) self.assertEqual('NotFound', resp.json['error']['type']) @mock.patch.object(policy.Enforcer, 'enforce') def test_delete(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete') deployment_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._delete('/software_deployments/%s' % deployment_id) return_value = None with mock.patch.object( self.controller.rpc_client, 'delete_software_deployment', return_value=return_value): self.assertRaises( webob.exc.HTTPNoContent, self.controller.delete, req, deployment_id=deployment_id, tenant_id=self.tenant) @mock.patch.object(policy.Enforcer, 'enforce') def test_delete_error(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete') deployment_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._delete('/software_deployments/%s' % deployment_id) error = Exception('something wrong') with mock.patch.object( self.controller.rpc_client, 'delete_software_deployment', side_effect=to_remote_error(error)): resp = request_with_middleware( fault.FaultWrapper, self.controller.delete, req, deployment_id=deployment_id, tenant_id=self.tenant) self.assertEqual(500, resp.json['code']) self.assertEqual('Exception', resp.json['error']['type']) @mock.patch.object(policy.Enforcer, 'enforce') def test_delete_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete') deployment_id = 'a45559cd-8736-4375-bc39-d6a7bb62ade2' req = self._delete('/software_deployments/%s' % deployment_id) error = heat_exc.NotFound('Not Found %s' % deployment_id) with mock.patch.object( self.controller.rpc_client, 'delete_software_deployment', side_effect=to_remote_error(error)): resp = request_with_middleware( fault.FaultWrapper, self.controller.delete, req, deployment_id=deployment_id, tenant_id=self.tenant) self.assertEqual(404, resp.json['code']) self.assertEqual('NotFound', resp.json['error']['type']) heat-2014.1.5/heat/tests/test_validate.py0000664000567000056700000013634112540642614021326 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. import collections from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import environment from heat.engine.hot.template import HOTemplate from heat.engine import parser from heat.engine import resources from heat.engine.resources import instance as instances from heat.engine import service from heat.openstack.common.importutils import try_import from heat.openstack.common.rpc import common as rpc_common from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes test_template_volumeattach = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "DeletionPolicy": "Delete", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": "test_KeyName" } }, "DataVolume" : { "Type" : "AWS::EC2::Volume", "Properties" : { "Size" : "6", "AvailabilityZone" : "nova" } }, "MountPoint" : { "Type" : "AWS::EC2::VolumeAttachment", "Properties" : { "InstanceId" : { "Ref" : "WikiDatabase" }, "VolumeId" : { "Ref" : "DataVolume" }, "Device" : "/dev/%s" } } } } ''' test_template_ref = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" } } }, "DataVolume" : { "Type" : "AWS::EC2::Volume", "Properties" : { "Size" : "6", "AvailabilityZone" : "nova" } }, "MountPoint" : { "Type" : "AWS::EC2::VolumeAttachment", "Properties" : { "InstanceId" : { "Ref" : "%s" }, "VolumeId" : { "Ref" : "DataVolume" }, "Device" : "/dev/vdb" } } } } ''' test_template_findinmap_valid = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2 KeyPair to' + \ 'enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" } } }, "DataVolume" : { "Type" : "AWS::EC2::Volume", "Properties" : { "Size" : "6", "AvailabilityZone" : "nova" } }, "MountPoint" : { "Type" : "AWS::EC2::VolumeAttachment", "Properties" : { "InstanceId" : { "Ref" : "WikiDatabase" }, "VolumeId" : { "Ref" : "DataVolume" }, "Device" : "/dev/vdb" } } } } ''' test_template_findinmap_invalid = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2 KeyPair to enable SSH ' + \ 'access to the instances",' + \ ''' "Type" : "String" } }, "Mappings" : { "AWSInstanceType2Arch" : { "t1.micro" : { "Arch" : "64" }, "m1.small" : { "Arch" : "64" }, "m1.medium" : { "Arch" : "64" }, "m1.large" : { "Arch" : "64" }, "m1.xlarge" : { "Arch" : "64" }, "m2.xlarge" : { "Arch" : "64" }, "m2.2xlarge" : { "Arch" : "64" }, "m2.4xlarge" : { "Arch" : "64" }, "c1.medium" : { "Arch" : "64" }, "c1.xlarge" : { "Arch" : "64" }, "cc1.4xlarge" : { "Arch" : "64HVM" }, "cc2.8xlarge" : { "Arch" : "64HVM" }, "cg1.4xlarge" : { "Arch" : "64HVM" } } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Properties": { ''' + \ '"ImageId" : { "Fn::FindInMap" : [ "DistroArch2AMI", { "Ref" : ' + \ '"LinuxDistribution" },' + \ '{ "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : ' + \ '"InstanceType" }, "Arch" ] } ] },' + \ ''' "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName"} } }, "DataVolume" : { "Type" : "AWS::EC2::Volume", "Properties" : { "Size" : "6", "AvailabilityZone" : "nova" } }, "MountPoint" : { "Type" : "AWS::EC2::VolumeAttachment", "Properties" : { "InstanceId" : { "Ref" : "WikiDatabase" }, "VolumeId" : { "Ref" : "DataVolume" }, "Device" : "/dev/vdb" } } } } ''' test_template_invalid_resources = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "AWS CloudFormation Sample Template for xyz.", "Parameters" : { "InstanceType" : { "Description" : "Defined instance type", "Type" : "String", "Default" : "node.ee", "AllowedValues" : ["node.ee", "node.apache", "node.api"], "ConstraintDescription" : "must be a valid instance type." } }, "Resources" : { "Type" : "AWS::EC2::Instance", "Metadata" : { }, "Properties" : { "ImageId" : { "Ref" : "centos-6.4-20130701-0" }, "InstanceType" : { "Ref" : "InstanceType" } } } } ''' test_template_invalid_property = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" }, "UnknownProperty": "unknown" } } } } ''' test_template_unimplemented_property = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" }, "SourceDestCheck": "false" } } } } ''' test_template_invalid_deletion_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "DeletionPolicy": "Destroy", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" } } } } } ''' test_template_snapshot_deletion_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "DeletionPolicy": "Snapshot", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" } } } } } ''' test_template_volume_snapshot = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Resources" : { "DataVolume" : { "Type" : "AWS::EC2::Volume", "DeletionPolicy": "Snapshot", "Properties" : { "Size" : "6", "AvailabilityZone" : "nova" } } } } ''' test_unregistered_key = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "Instance": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" } } } } } ''' test_template_image = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "Instance": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" } } } } } ''' test_template_invalid_secgroups = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "Instance": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" }, "SecurityGroups": [ "default" ], "NetworkInterfaces": [ "mgmt", "data" ] } } } } ''' test_template_invalid_secgroupids = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "Instance": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" }, "SecurityGroupIds": [ "default" ], "NetworkInterfaces": [ "mgmt", "data" ] } } } } ''' test_template_nova_client_exception = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Resources" : { "Instance": { "Type": "AWS::EC2::Instance", "DeletionPolicy": "Delete", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large" } } } } ''' test_template_unique_logical_name = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" }, "AName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String" } }, "Resources" : { "AName": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" }, "NetworkInterfaces": [ "mgmt", "data" ] } } } } ''' test_template_cfn_parameter_label = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "test.", "Parameters" : { "KeyName" : { ''' + \ '"Description" : "Name of an existing EC2' + \ 'KeyPair to enable SSH access to the instances",' + \ ''' "Type" : "String", "Label" : "Nova KeyPair Name" }, }, "Resources" : { "AName": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "image_name", "InstanceType": "m1.large", "KeyName": { "Ref" : "KeyName" }, "NetworkInterfaces": [ "mgmt", "data" ] } } } } ''' test_template_hot_parameter_label = ''' heat_template_version: 2013-05-23 description: > Hello world HOT template that just defines a single compute instance. Contains just base features to verify base HOT support. parameters: KeyName: type: string description: Name of an existing key pair to use for the instance label: Nova KeyPair Name resources: my_instance: type: AWS::EC2::Instance properties: KeyName: { get_param: KeyName } ImageId: { get_param: ImageId } InstanceType: { get_param: InstanceType } outputs: instance_ip: description: The IP address of the deployed instance value: { get_attr: [my_instance, PublicIp] } ''' test_template_duplicate_parameters = ''' # This is a hello world HOT template just defining a single compute instance heat_template_version: 2013-05-23 parameter_groups: - label: Server Group description: A group of parameters for the server parameters: - InstanceType - KeyName - ImageId - label: Database Group description: A group of parameters for the database parameters: - db_password - db_port - InstanceType parameters: KeyName: type: string description: Name of an existing key pair to use for the instance InstanceType: type: string description: Instance type for the instance to be created default: m1.small constraints: - allowed_values: [m1.tiny, m1.small, m1.large] description: Value must be one of 'm1.tiny', 'm1.small' or 'm1.large' ImageId: type: string description: ID of the image to use for the instance # parameters below are not used in template, but are for verifying parameter # validation support in HOT db_password: type: string description: Database password 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 db_port: type: number description: Database port number default: 50000 constraints: - range: { min: 40000, max: 60000 } description: Port number must be between 40000 and 60000 resources: my_instance: # Use an AWS resource type since this exists; so why use other name here? type: AWS::EC2::Instance properties: KeyName: { get_param: KeyName } ImageId: { get_param: ImageId } InstanceType: { get_param: InstanceType } outputs: instance_ip: description: The IP address of the deployed instance value: { get_attr: [my_instance, PublicIp] } ''' test_template_invalid_parameter_name = ''' # This is a hello world HOT template just defining a single compute instance heat_template_version: 2013-05-23 description: > Hello world HOT template that just defines a single compute instance. Contains just base features to verify base HOT support. parameter_groups: - label: Server Group description: A group of parameters for the server parameters: - InstanceType - KeyName - ImageId - label: Database Group description: A group of parameters for the database parameters: - db_password - db_port - SomethingNotHere parameters: KeyName: type: string description: Name of an existing key pair to use for the instance InstanceType: type: string description: Instance type for the instance to be created default: m1.small constraints: - allowed_values: [m1.tiny, m1.small, m1.large] description: Value must be one of 'm1.tiny', 'm1.small' or 'm1.large' ImageId: type: string description: ID of the image to use for the instance # parameters below are not used in template, but are for verifying parameter # validation support in HOT db_password: type: string description: Database password 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 db_port: type: number description: Database port number default: 50000 constraints: - range: { min: 40000, max: 60000 } description: Port number must be between 40000 and 60000 resources: my_instance: # Use an AWS resource type since this exists; so why use other name here? type: AWS::EC2::Instance properties: KeyName: { get_param: KeyName } ImageId: { get_param: ImageId } InstanceType: { get_param: InstanceType } outputs: instance_ip: description: The IP address of the deployed instance value: { get_attr: [my_instance, PublicIp] } ''' test_template_hot_no_parameter_label = ''' heat_template_version: 2013-05-23 description: > Hello world HOT template that just defines a single compute instance. Contains just base features to verify base HOT support. parameters: KeyName: type: string description: Name of an existing key pair to use for the instance resources: my_instance: type: AWS::EC2::Instance properties: KeyName: { get_param: KeyName } ImageId: { get_param: ImageId } InstanceType: { get_param: InstanceType } ''' test_template_no_parameters = ''' heat_template_version: 2013-05-23 description: > Hello world HOT template that just defines a single compute instance. Contains just base features to verify base HOT support. parameter_groups: - label: Server Group description: A group of parameters for the server - label: Database Group description: A group of parameters for the database ''' test_template_default_override = ''' heat_template_version: 2013-05-23 description: create a network parameters: net_name: type: string default: defaultnet description: Name of private network to be created resources: private_net: type: OS::Neutron::Net properties: name: { get_param: net_name } ''' test_template_no_default = ''' heat_template_version: 2013-05-23 description: create a network parameters: net_name: type: string description: Name of private network to be created resources: private_net: type: OS::Neutron::Net properties: name: { get_param: net_name } ''' class validateTest(HeatTestCase): def setUp(self): super(validateTest, self).setUp() resources.initialise() self.fc = fakes.FakeClient() resources.initialise() utils.setup_dummy_db() self.ctx = utils.dummy_context() def test_validate_volumeattach_valid(self): t = template_format.parse(test_template_volumeattach % 'vdq') stack = parser.Stack(self.ctx, 'test_stack', parser.Template(t)) volumeattach = stack['MountPoint'] self.assertIsNone(volumeattach.validate()) def test_validate_volumeattach_invalid(self): t = template_format.parse(test_template_volumeattach % 'sda') stack = parser.Stack(self.ctx, 'test_stack', parser.Template(t)) volumeattach = stack['MountPoint'] self.assertRaises(exception.StackValidationFailed, volumeattach.validate) def test_validate_ref_valid(self): t = template_format.parse(test_template_ref % 'WikiDatabase') self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual('test.', res['Description']) def test_validate_with_environment(self): test_template = test_template_ref % 'WikiDatabase' test_template = test_template.replace('AWS::EC2::Instance', 'My::Instance') t = template_format.parse(test_template) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') params = {'resource_registry': {'My::Instance': 'AWS::EC2::Instance'}} res = dict(engine.validate_template(None, t, params)) self.assertEqual('test.', res['Description']) def test_validate_hot_valid(self): t = template_format.parse( """ heat_template_version: 2013-05-23 description: test. resources: my_instance: type: AWS::EC2::Instance """) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual('test.', res['Description']) def test_validate_ref_invalid(self): t = template_format.parse(test_template_ref % 'WikiDatabasez') self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertNotEqual(res['Description'], 'Successfully validated') def test_validate_findinmap_valid(self): t = template_format.parse(test_template_findinmap_valid) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual('test.', res['Description']) def test_validate_findinmap_invalid(self): t = template_format.parse(test_template_findinmap_invalid) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertNotEqual(res['Description'], 'Successfully validated') def test_validate_parameters(self): t = template_format.parse(test_template_ref % 'WikiDatabase') self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) # Note: the assertion below does not expect a CFN dict of the parameter # but a dict of the parameters.Schema object. # For API CFN backward compatibility, formating to CFN is done in the # API layer in heat.engine.api.format_validate_parameter. expected = {'KeyName': { 'Type': 'String', 'Description': 'Name of an existing EC2KeyPair to enable SSH ' 'access to the instances', 'NoEcho': 'false', 'Label': 'KeyName'}} self.assertEqual(expected, res['Parameters']) def test_validate_parameters_env_override(self): t = template_format.parse(test_template_default_override) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() env_params = {'net_name': 'betternetname'} engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, env_params)) self.assertEqual('betternetname', res['Parameters']['net_name']['Default']) def test_validate_parameters_env_provided(self): t = template_format.parse(test_template_no_default) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() env_params = {'net_name': 'betternetname'} engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, env_params)) self.assertEqual('betternetname', res['Parameters']['net_name']['Default']) def test_validate_hot_parameter_label(self): t = template_format.parse(test_template_hot_parameter_label) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) parameters = res['Parameters'] expected = {'KeyName': { 'Type': 'String', 'Description': 'Name of an existing key pair to use for the ' 'instance', 'NoEcho': 'false', 'Label': 'Nova KeyPair Name'}} self.assertEqual(expected, parameters) def test_validate_hot_no_parameter_label(self): t = template_format.parse(test_template_hot_no_parameter_label) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) parameters = res['Parameters'] expected = {'KeyName': { 'Type': 'String', 'Description': 'Name of an existing key pair to use for the ' 'instance', 'NoEcho': 'false', 'Label': 'KeyName'}} self.assertEqual(expected, parameters) def test_validate_cfn_parameter_label(self): t = template_format.parse(test_template_cfn_parameter_label) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) parameters = res['Parameters'] expected = {'KeyName': { 'Type': 'String', 'Description': 'Name of an existing EC2KeyPair to enable SSH ' 'access to the instances', 'NoEcho': 'false', 'Label': 'Nova KeyPair Name'}} self.assertEqual(expected, parameters) def test_validate_properties(self): t = template_format.parse(test_template_invalid_property) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual({'Error': 'Unknown Property UnknownProperty'}, res) def test_invalid_resources(self): t = template_format.parse(test_template_invalid_resources) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual({'Error': 'Resources must contain Resource. ' 'Found a [string] instead'}, res) def test_invalid_section_cfn(self): t = template_format.parse( """ { 'AWSTemplateFormatVersion': '2010-09-09', 'Resources': { 'server': { 'Type': 'OS::Nova::Server' } }, 'Output': {} } """) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') ex = self.assertRaises(rpc_common.ClientException, engine.validate_template, None, t) self.assertEqual(ex._exc_info[0], exception.InvalidTemplateSection) self.assertEqual('The template section is invalid: Output', str(ex._exc_info[1])) def test_invalid_section_hot(self): t = template_format.parse( """ heat_template_version: 2013-05-23 resources: server: type: OS::Nova::Server output: """) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') ex = self.assertRaises(rpc_common.ClientException, engine.validate_template, None, t) self.assertEqual(ex._exc_info[0], exception.InvalidTemplateSection) self.assertEqual('The template section is invalid: output', str(ex._exc_info[1])) def test_unimplemented_property(self): t = template_format.parse(test_template_unimplemented_property) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual( {'Error': 'Property SourceDestCheck not implemented yet'}, res) def test_invalid_deletion_policy(self): t = template_format.parse(test_template_invalid_deletion_policy) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual({'Error': 'Invalid DeletionPolicy Destroy'}, res) def test_snapshot_deletion_policy(self): t = template_format.parse(test_template_snapshot_deletion_policy) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual( {'Error': 'Snapshot DeletionPolicy not supported'}, res) @skipIf(try_import('cinderclient.v1.volume_backups') is None, 'unable to import volume_backups') def test_volume_snapshot_deletion_policy(self): t = template_format.parse(test_template_volume_snapshot) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, t, {})) self.assertEqual({'Description': u'test.', 'Parameters': {}}, res) def test_validate_template_without_resources(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'At least one Resources member ' 'must be defined.'}, res) def test_validate_template_with_invalid_resource_type(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: Type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'u\'"Type" is not a valid keyword ' 'inside a resource definition\''}, res) def test_validate_template_with_invalid_resource_properties(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance Properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'u\'"Properties" is not a valid keyword ' 'inside a resource definition\''}, res) def test_validate_template_with_invalid_resource_matadata(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 Metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'u\'"Metadata" is not a valid keyword ' 'inside a resource definition\''}, res) def test_validate_template_with_invalid_resource_depends_on(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar DependsOn: dummy deletion_policy: dummy update_policy: foo: bar ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'u\'"DependsOn" is not a valid keyword ' 'inside a resource definition\''}, res) def test_validate_template_with_invalid_resource_deletion_polciy(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy DeletionPolicy: dummy update_policy: foo: bar ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'u\'"DeletionPolicy" is not a valid ' 'keyword inside a resource definition\''}, res) def test_validate_template_with_invalid_resource_update_policy(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy UpdatePolicy: foo: bar ''') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() engine = service.EngineService('a', 't') res = dict(engine.validate_template(None, hot_tpl, {})) self.assertEqual({'Error': 'u\'"UpdatePolicy" is not a valid ' 'keyword inside a resource definition\''}, res) def test_unregistered_key(self): t = template_format.parse(test_unregistered_key) template = parser.Template(t) params = {'KeyName': 'not_registered'} stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment(params)) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().AndReturn(self.fc) self.m.ReplayAll() resource = stack['Instance'] self.assertRaises(exception.StackValidationFailed, resource.validate) def test_unregistered_image(self): t = template_format.parse(test_template_image) template = parser.Template(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({'KeyName': 'test'})) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().AndReturn(self.fc) self.m.ReplayAll() resource = stack['Instance'] self.assertRaises(exception.StackValidationFailed, resource.validate) self.m.VerifyAll() def test_duplicated_image(self): t = template_format.parse(test_template_image) template = parser.Template(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({'KeyName': 'test'})) image_type = collections.namedtuple("Image", ("id", "name")) image_list = [image_type(id='768b5464-3df5-4abf-be33-63b60f8b99d0', name='image_name'), image_type(id='a57384f5-690f-48e1-bf46-c4291e6c887e', name='image_name')] self.m.StubOutWithMock(self.fc.images, 'list') self.fc.images.list().AndReturn(image_list) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().AndReturn(self.fc) self.m.ReplayAll() resource = stack['Instance'] self.assertRaises(exception.StackValidationFailed, resource.validate) self.m.VerifyAll() def test_invalid_security_groups_with_nics(self): t = template_format.parse(test_template_invalid_secgroups) template = parser.Template(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({'KeyName': 'test'})) image_type = collections.namedtuple("Image", ("id", "name")) image_list = [image_type(id='768b5464-3df5-4abf-be33-63b60f8b99d0', name='image_name')] self.m.StubOutWithMock(self.fc.images, 'list') self.fc.images.list().AndReturn(image_list) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() resource = stack['Instance'] self.assertRaises(exception.ResourcePropertyConflict, resource.validate) def test_invalid_security_group_ids_with_nics(self): t = template_format.parse(test_template_invalid_secgroupids) template = parser.Template(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({'KeyName': 'test'})) image_type = collections.namedtuple("Image", ("id", "name")) image_list = [image_type(id='768b5464-3df5-4abf-be33-63b60f8b99d0', name='image_name')] self.m.StubOutWithMock(self.fc.images, 'list') self.fc.images.list().AndReturn(image_list) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() resource = stack['Instance'] self.assertRaises(exception.ResourcePropertyConflict, resource.validate) def test_client_exception_from_nova_client(self): t = template_format.parse(test_template_nova_client_exception) template = parser.Template(t) stack = parser.Stack(self.ctx, 'test_stack', template) self.m.StubOutWithMock(self.fc.images, 'list') self.fc.images.list().AndRaise( clients.novaclient.exceptions.ClientException(500)) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertRaises(exception.StackValidationFailed, stack.validate) self.m.VerifyAll() def test_validate_unique_logical_name(self): t = template_format.parse(test_template_unique_logical_name) template = parser.Template(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({'AName': 'test', 'KeyName': 'test'})) self.assertRaises(exception.StackValidationFailed, stack.validate) def test_validate_duplicate_parameters_in_group(self): t = template_format.parse(test_template_duplicate_parameters) template = HOTemplate(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({ 'KeyName': 'test', 'ImageId': 'sometestid', 'db_password': 'Pass123' })) exc = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertEqual(_('The InstanceType parameter must be assigned to ' 'one Parameter Group only.'), str(exc)) def test_validate_invalid_parameter_in_group(self): t = template_format.parse(test_template_invalid_parameter_name) template = HOTemplate(t) stack = parser.Stack(self.ctx, 'test_stack', template, environment.Environment({ 'KeyName': 'test', 'ImageId': 'sometestid', 'db_password': 'Pass123'})) exc = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertEqual(_('The Parameter name (SomethingNotHere) does not ' 'reference an existing parameter.'), str(exc)) def test_validate_no_parameters_in_group(self): t = template_format.parse(test_template_no_parameters) template = HOTemplate(t) stack = parser.Stack(self.ctx, 'test_stack', template) exc = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertEqual(_('Parameters must be provided for each Parameter ' 'Group.'), str(exc)) heat-2014.1.5/heat/tests/test_api_cfn_v1.py0000664000567000056700000023007212540642614021536 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. import json import os import mock from oslo.config import cfg from heat.api.aws import exception import heat.api.cfn.v1.stacks as stacks from heat.common import exception as heat_exception from heat.common import identifier from heat.common import policy from heat.common.wsgi import Request from heat.openstack.common import rpc from heat.rpc import api as rpc_api from heat.tests.common import HeatTestCase from heat.tests import utils policy_path = os.path.dirname(os.path.realpath(__file__)) + "/policy/" class CfnStackControllerTest(HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def setUp(self): super(CfnStackControllerTest, self).setUp() opts = [ cfg.StrOpt('config_dir', default=policy_path), cfg.StrOpt('config_file', default='foo'), cfg.StrOpt('project', default='heat'), ] cfg.CONF.register_opts(opts) cfg.CONF.set_default('host', 'host') self.topic = rpc_api.ENGINE_TOPIC self.api_version = '1.0' self.template = {u'AWSTemplateFormatVersion': u'2010-09-09', u'Foo': u'bar'} # Create WSGI controller instance class DummyConfig(): bind_port = 8000 cfgopts = DummyConfig() self.controller = stacks.StackController(options=cfgopts) self.controller.policy.enforcer.policy_path = (policy_path + 'deny_stack_user.json') self.addCleanup(self.m.VerifyAll) def _dummy_GET_request(self, params={}): # Mangle the params dict into a query string qs = "&".join(["=".join([k, str(params[k])]) for k in params]) environ = {'REQUEST_METHOD': 'GET', 'QUERY_STRING': qs} req = Request(environ) req.context = utils.dummy_context() return req def _stub_enforce(self, req, action, allowed=True): self.m.StubOutWithMock(policy.Enforcer, 'enforce') if allowed: policy.Enforcer.enforce(req.context, action ).AndReturn(True) else: policy.Enforcer.enforce(req.context, action ).AndRaise(heat_exception.Forbidden) self.m.ReplayAll() # The tests def test_stackid_addprefix(self): self.m.ReplayAll() response = self.controller._id_format({ 'StackName': 'Foo', 'StackId': { u'tenant': u't', u'stack_name': u'Foo', u'stack_id': u'123', u'path': u'' } }) expected = {'StackName': 'Foo', 'StackId': 'arn:openstack:heat::t:stacks/Foo/123'} self.assertEqual(expected, response) def test_enforce_ok(self): params = {'Action': 'ListStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStacks') response = self.controller._enforce(dummy_req, 'ListStacks') self.assertIsNone(response) def test_enforce_denied(self): self.m.ReplayAll() params = {'Action': 'ListStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStacks', False) self.assertRaises(exception.HeatAccessDeniedError, self.controller._enforce, dummy_req, 'ListStacks') def test_enforce_ise(self): params = {'Action': 'ListStacks'} dummy_req = self._dummy_GET_request(params) dummy_req.context.roles = ['heat_stack_user'] self.m.StubOutWithMock(policy.Enforcer, 'enforce') policy.Enforcer.enforce(dummy_req.context, 'ListStacks' ).AndRaise(AttributeError) self.m.ReplayAll() self.assertRaises(exception.HeatInternalFailureError, self.controller._enforce, dummy_req, 'ListStacks') @mock.patch.object(rpc, 'call') def test_list(self, mock_call): # Format a dummy GET request to pass into the WSGI handler params = {'Action': 'ListStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStacks') # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'1', u'path': u''}, u'updated_time': u'2012-07-09T09:13:11Z', u'template_description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': u'wordpress', u'stack_action': u'CREATE', u'stack_status': u'COMPLETE'}] mock_call.return_value = engine_resp # Call the list controller function and compare the response result = self.controller.list(dummy_req) expected = {'ListStacksResponse': {'ListStacksResult': {'StackSummaries': [{u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1', u'LastUpdatedTime': u'2012-07-09T09:13:11Z', u'TemplateDescription': u'blah', u'StackStatusReason': u'Stack successfully created', u'CreationTime': u'2012-07-09T09:12:45Z', u'StackName': u'wordpress', u'StackStatus': u'CREATE_COMPLETE'}]}}} self.assertEqual(expected, result) default_args = {'limit': None, 'sort_keys': None, 'marker': None, 'sort_dir': None, 'filters': None, 'tenant_safe': True} mock_call.assert_called_once_with(dummy_req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': default_args, 'version': self.api_version}, None) @mock.patch.object(rpc, 'call') def test_list_rmt_aterr(self, mock_call): params = {'Action': 'ListStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStacks') # Insert an engine RPC error and ensure we map correctly to the # heat exception type mock_call.side_effect = AttributeError # Call the list controller function and compare the response result = self.controller.list(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) mock_call.assert_called_once_with(dummy_req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': mock.ANY, 'version': self.api_version}, None) @mock.patch.object(rpc, 'call') def test_list_rmt_interr(self, mock_call): params = {'Action': 'ListStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStacks') # Insert an engine RPC error and ensure we map correctly to the # heat exception type mock_call.side_effect = Exception() # Call the list controller function and compare the response result = self.controller.list(dummy_req) self.assertIsInstance(result, exception.HeatInternalFailureError) mock_call.assert_called_once_with(dummy_req.context, self.topic, {'namespace': None, 'method': 'list_stacks', 'args': mock.ANY, 'version': self.api_version}, None) def test_describe_last_updated_time(self): params = {'Action': 'DescribeStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') engine_resp = [{u'updated_time': '1970-01-01', u'parameters': {}, u'stack_action': u'CREATE', u'stack_status': u'COMPLETE'}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': None}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.describe(dummy_req) result = response['DescribeStacksResponse']['DescribeStacksResult'] stack = result['Stacks'][0] self.assertEqual('1970-01-01', stack['LastUpdatedTime']) def test_describe_no_last_updated_time(self): params = {'Action': 'DescribeStacks'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') engine_resp = [{u'updated_time': None, u'parameters': {}, u'stack_action': u'CREATE', u'stack_status': u'COMPLETE'}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': None}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.describe(dummy_req) result = response['DescribeStacksResponse']['DescribeStacksResult'] stack = result['Stacks'][0] self.assertNotIn('LastUpdatedTime', stack) def test_describe(self): # Format a dummy GET request to pass into the WSGI handler stack_name = u"wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStacks', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') # Stub out the RPC call to the engine with a pre-canned response # Note the engine returns a load of keys we don't actually use # so this is a subset of the real response format engine_resp = [{u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'updated_time': u'2012-07-09T09:13:11Z', u'parameters': {u'DBUsername': u'admin', u'LinuxDistribution': u'F17', u'InstanceType': u'm1.large', u'DBRootPassword': u'admin', u'DBPassword': u'admin', u'DBName': u'wordpress'}, u'outputs': [{u'output_key': u'WebsiteURL', u'description': u'URL for Wordpress wiki', u'output_value': u'http://10.0.0.8/wordpress'}], u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': u'wordpress', u'notification_topics': [], u'stack_action': u'CREATE', u'stack_status': u'COMPLETE', u'description': u'blah', u'disable_rollback': 'true', u'timeout_mins':60, u'capabilities':[]}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() # Call the list controller function and compare the response response = self.controller.describe(dummy_req) expected = {'DescribeStacksResponse': {'DescribeStacksResult': {'Stacks': [{'StackId': u'arn:openstack:heat::t:stacks/wordpress/6', 'StackStatusReason': u'Stack successfully created', 'Description': u'blah', 'Parameters': [{'ParameterValue': u'admin', 'ParameterKey': u'DBUsername'}, {'ParameterValue': u'F17', 'ParameterKey': u'LinuxDistribution'}, {'ParameterValue': u'm1.large', 'ParameterKey': u'InstanceType'}, {'ParameterValue': u'admin', 'ParameterKey': u'DBRootPassword'}, {'ParameterValue': u'admin', 'ParameterKey': u'DBPassword'}, {'ParameterValue': u'wordpress', 'ParameterKey': u'DBName'}], 'Outputs': [{'OutputKey': u'WebsiteURL', 'OutputValue': u'http://10.0.0.8/wordpress', 'Description': u'URL for Wordpress wiki'}], 'TimeoutInMinutes': 60, 'CreationTime': u'2012-07-09T09:12:45Z', 'Capabilities': [], 'StackName': u'wordpress', 'NotificationARNs': [], 'StackStatus': u'CREATE_COMPLETE', 'DisableRollback': 'true', 'LastUpdatedTime': u'2012-07-09T09:13:11Z'}]}}} self.assertEqual(expected, response) def test_describe_arn(self): # Format a dummy GET request to pass into the WSGI handler stack_name = u"wordpress" stack_identifier = identifier.HeatIdentifier('t', stack_name, '6') identity = dict(stack_identifier) params = {'Action': 'DescribeStacks', 'StackName': stack_identifier.arn()} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') # Stub out the RPC call to the engine with a pre-canned response # Note the engine returns a load of keys we don't actually use # so this is a subset of the real response format engine_resp = [{u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'updated_time': u'2012-07-09T09:13:11Z', u'parameters': {u'DBUsername': u'admin', u'LinuxDistribution': u'F17', u'InstanceType': u'm1.large', u'DBRootPassword': u'admin', u'DBPassword': u'admin', u'DBName': u'wordpress'}, u'outputs': [{u'output_key': u'WebsiteURL', u'description': u'URL for Wordpress wiki', u'output_value': u'http://10.0.0.8/wordpress'}], u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': u'wordpress', u'notification_topics': [], u'stack_action': u'CREATE', u'stack_status': u'COMPLETE', u'description': u'blah', u'disable_rollback': 'true', u'timeout_mins':60, u'capabilities':[]}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() # Call the list controller function and compare the response response = self.controller.describe(dummy_req) expected = {'DescribeStacksResponse': {'DescribeStacksResult': {'Stacks': [{'StackId': u'arn:openstack:heat::t:stacks/wordpress/6', 'StackStatusReason': u'Stack successfully created', 'Description': u'blah', 'Parameters': [{'ParameterValue': u'admin', 'ParameterKey': u'DBUsername'}, {'ParameterValue': u'F17', 'ParameterKey': u'LinuxDistribution'}, {'ParameterValue': u'm1.large', 'ParameterKey': u'InstanceType'}, {'ParameterValue': u'admin', 'ParameterKey': u'DBRootPassword'}, {'ParameterValue': u'admin', 'ParameterKey': u'DBPassword'}, {'ParameterValue': u'wordpress', 'ParameterKey': u'DBName'}], 'Outputs': [{'OutputKey': u'WebsiteURL', 'OutputValue': u'http://10.0.0.8/wordpress', 'Description': u'URL for Wordpress wiki'}], 'TimeoutInMinutes': 60, 'CreationTime': u'2012-07-09T09:12:45Z', 'Capabilities': [], 'StackName': u'wordpress', 'NotificationARNs': [], 'StackStatus': u'CREATE_COMPLETE', 'DisableRollback': 'true', 'LastUpdatedTime': u'2012-07-09T09:13:11Z'}]}}} self.assertEqual(expected, response) def test_describe_arn_invalidtenant(self): # Format a dummy GET request to pass into the WSGI handler stack_name = u"wordpress" stack_identifier = identifier.HeatIdentifier('wibble', stack_name, '6') identity = dict(stack_identifier) params = {'Action': 'DescribeStacks', 'StackName': stack_identifier.arn()} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndRaise(heat_exception.InvalidTenant(target='test', actual='test')) self.m.ReplayAll() result = self.controller.describe(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_describe_aterr(self): stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStacks', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'show_stack', 'args': {'stack_identity': identity}, 'version': self.api_version}, None ).AndRaise(AttributeError()) self.m.ReplayAll() result = self.controller.describe(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_describe_bad_name(self): stack_name = "wibble" params = {'Action': 'DescribeStacks', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStacks') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.describe(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_get_template_int_body(self): '''Test the internal _get_template function.''' params = {'TemplateBody': "abcdef"} dummy_req = self._dummy_GET_request(params) result = self.controller._get_template(dummy_req) expected = "abcdef" self.assertEqual(expected, result) # TODO(shardy) : test the _get_template TemplateUrl case def test_create(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'DisableRollback': 'true', 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30', 'disable_rollback': 'true'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Stub out the RPC call to the engine with a pre-canned response engine_resp = {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'1', u'path': u''} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.create(dummy_req) expected = { 'CreateStackResponse': { 'CreateStackResult': { u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1' } } } self.assertEqual(expected, response) def test_create_rollback(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'DisableRollback': 'false', 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30', 'disable_rollback': 'false'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Stub out the RPC call to the engine with a pre-canned response engine_resp = {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'1', u'path': u''} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.create(dummy_req) expected = { 'CreateStackResponse': { 'CreateStackResult': { u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1' } } } self.assertEqual(expected, response) def test_create_onfailure_true(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'OnFailure': 'DO_NOTHING', 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30', 'disable_rollback': 'true'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Stub out the RPC call to the engine with a pre-canned response engine_resp = {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'1', u'path': u''} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.create(dummy_req) expected = { 'CreateStackResponse': { 'CreateStackResult': { u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1' } } } self.assertEqual(expected, response) def test_create_onfailure_false_delete(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'OnFailure': 'DELETE', 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30', 'disable_rollback': 'false'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Stub out the RPC call to the engine with a pre-canned response engine_resp = {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'1', u'path': u''} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.create(dummy_req) expected = { 'CreateStackResponse': { 'CreateStackResult': { u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1' } } } self.assertEqual(expected, response) def test_create_onfailure_false_rollback(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'OnFailure': 'ROLLBACK', 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30', 'disable_rollback': 'false'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Stub out the RPC call to the engine with a pre-canned response engine_resp = {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'1', u'path': u''} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.create(dummy_req) expected = { 'CreateStackResponse': { 'CreateStackResult': { u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1' } } } self.assertEqual(expected, response) def test_create_onfailure_err(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'DisableRollback': 'true', 'OnFailure': 'DO_NOTHING', 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') self.assertRaises(exception.HeatInvalidParameterCombinationError, self.controller.create, dummy_req) def test_create_err_no_template(self): # Format a dummy request with a missing template field stack_name = "wordpress" params = {'Action': 'CreateStack', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.HeatMissingParameterError) def test_create_err_inval_template(self): # Format a dummy request with an invalid TemplateBody stack_name = "wordpress" json_template = "!$%**_+}@~?" params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_create_err_rpcerr(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30'} dummy_req = self._dummy_GET_request(params) self.m.StubOutWithMock(policy.Enforcer, 'enforce') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') policy.Enforcer.enforce(dummy_req.context, 'CreateStack' ).AndReturn(True) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None ).AndRaise(AttributeError()) policy.Enforcer.enforce(dummy_req.context, 'CreateStack' ).AndReturn(True) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None ).AndRaise(heat_exception.UnknownUserParameter(key='test')) policy.Enforcer.enforce(dummy_req.context, 'CreateStack' ).AndReturn(True) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None ).AndRaise(heat_exception.UserParameterMissing(key='test')) self.m.ReplayAll() result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_create_err_exists(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackExists(stack_name='test')) self.m.ReplayAll() result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.AlreadyExistsError) def test_create_err_engine(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'CreateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'TimeoutInMinutes': 30, 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {'timeout_mins': u'30'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'CreateStack') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'create_stack', 'args': {'stack_name': stack_name, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndRaise( heat_exception.StackValidationFailed( message='Something went wrong')) self.m.ReplayAll() result = self.controller.create(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_update(self): # Format a dummy request stack_name = "wordpress" json_template = json.dumps(self.template) params = {'Action': 'UpdateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} engine_parms = {u'InstanceType': u'm1.xlarge'} engine_args = {} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'UpdateStack') # Stub out the RPC call to the engine with a pre-canned response identity = dict(identifier.HeatIdentifier('t', stack_name, '1')) self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'update_stack', 'args': {'stack_identity': identity, 'template': self.template, 'params': engine_parms, 'files': {}, 'args': engine_args}, 'version': self.api_version}, None).AndReturn(identity) self.m.ReplayAll() response = self.controller.update(dummy_req) expected = { 'UpdateStackResponse': { 'UpdateStackResult': { u'StackId': u'arn:openstack:heat::t:stacks/wordpress/1' } } } self.assertEqual(expected, response) def test_update_bad_name(self): stack_name = "wibble" json_template = json.dumps(self.template) params = {'Action': 'UpdateStack', 'StackName': stack_name, 'TemplateBody': '%s' % json_template, 'Parameters.member.1.ParameterKey': 'InstanceType', 'Parameters.member.1.ParameterValue': 'm1.xlarge'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'UpdateStack') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.update(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_create_or_update_err(self): result = self.controller.create_or_update(req={}, action="dsdgfdf") self.assertIsInstance(result, exception.HeatInternalFailureError) def test_get_template(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'GetTemplate', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'GetTemplate') # Stub out the RPC call to the engine with a pre-canned response engine_resp = self.template self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'get_template', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.get_template(dummy_req) expected = {'GetTemplateResponse': {'GetTemplateResult': {'TemplateBody': self.template}}} self.assertEqual(expected, response) def test_get_template_err_rpcerr(self): stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'GetTemplate', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'GetTemplate') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'get_template', 'args': {'stack_identity': identity}, 'version': self.api_version}, None ).AndRaise(AttributeError()) self.m.ReplayAll() result = self.controller.get_template(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_get_template_bad_name(self): stack_name = "wibble" params = {'Action': 'GetTemplate', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'GetTemplate') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.get_template(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_get_template_err_none(self): stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'GetTemplate', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'GetTemplate') # Stub out the RPC call to the engine to return None # this test the "no such stack" error path engine_resp = None self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'get_template', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() result = self.controller.get_template(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_validate_err_no_template(self): # Format a dummy request with a missing template field params = {'Action': 'ValidateTemplate'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ValidateTemplate') result = self.controller.validate_template(dummy_req) self.assertIsInstance(result, exception.HeatMissingParameterError) def test_validate_err_inval_template(self): # Format a dummy request with an invalid TemplateBody json_template = "!$%**_+}@~?" params = {'Action': 'ValidateTemplate', 'TemplateBody': '%s' % json_template} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ValidateTemplate') result = self.controller.validate_template(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_bad_resources_in_template(self): # Format a dummy request json_template = { 'AWSTemplateFormatVersion': '2010-09-09', 'Resources': { 'Type': 'AWS: : EC2: : Instance', }, } params = {'Action': 'ValidateTemplate', 'TemplateBody': '%s' % json.dumps(json_template)} response = {'Error': 'Resources must contain Resource. ' 'Found a [string] instead'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ValidateTemplate') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'validate_template', 'args': {'template': json_template, 'params': None}, 'version': self.api_version}, None).AndReturn(response) self.m.ReplayAll() response = self.controller.validate_template(dummy_req) expected = {'ValidateTemplateResponse': {'ValidateTemplateResult': 'Resources must contain Resource. ' 'Found a [string] instead'}} self.assertEqual(expected, response) def test_delete(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '1')) params = {'Action': 'DeleteStack', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DeleteStack') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) # Engine returns None when delete successful rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'delete_stack', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(None) self.m.ReplayAll() response = self.controller.delete(dummy_req) expected = {'DeleteStackResponse': {'DeleteStackResult': ''}} self.assertEqual(expected, response) def test_delete_err_rpcerr(self): stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '1')) params = {'Action': 'DeleteStack', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DeleteStack') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) # Insert an engine RPC error and ensure we map correctly to the # heat exception type rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'delete_stack', 'args': {'stack_identity': identity}, 'version': self.api_version}, None ).AndRaise(AttributeError()) self.m.ReplayAll() result = self.controller.delete(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_delete_bad_name(self): stack_name = "wibble" params = {'Action': 'DeleteStack', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DeleteStack') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.delete(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_events_list_event_id_integer(self): self._test_events_list('42') def test_events_list_event_id_uuid(self): self._test_events_list('a3455d8c-9f88-404d-a85b-5315293e67de') def _test_events_list(self, event_id): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStackEvents', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackEvents') # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'stack_name': u'wordpress', u'event_time': u'2012-07-23T13:05:39Z', u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'resource_name': u'WikiDatabase', u'resource_status_reason': u'state changed', u'event_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u'/resources/WikiDatabase/events/{0}'.format( event_id)}, u'resource_action': u'TEST', u'resource_status': u'IN_PROGRESS', u'physical_resource_id': None, u'resource_properties': {u'UserData': u'blah'}, u'resource_type': u'AWS::EC2::Instance'}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.events_list(dummy_req) expected = {'DescribeStackEventsResponse': {'DescribeStackEventsResult': {'StackEvents': [{'EventId': unicode(event_id), 'StackId': u'arn:openstack:heat::t:stacks/wordpress/6', 'ResourceStatus': u'TEST_IN_PROGRESS', 'ResourceType': u'AWS::EC2::Instance', 'Timestamp': u'2012-07-23T13:05:39Z', 'StackName': u'wordpress', 'ResourceProperties': json.dumps({u'UserData': u'blah'}), 'PhysicalResourceId': None, 'ResourceStatusReason': u'state changed', 'LogicalResourceId': u'WikiDatabase'}]}}} self.assertEqual(expected, response) def test_events_list_err_rpcerr(self): stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStackEvents', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackEvents') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'list_events', 'args': {'stack_identity': identity}, 'version': self.api_version}, None ).AndRaise(Exception()) self.m.ReplayAll() result = self.controller.events_list(dummy_req) self.assertIsInstance(result, exception.HeatInternalFailureError) def test_events_list_bad_name(self): stack_name = "wibble" params = {'Action': 'DescribeStackEvents', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackEvents') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.events_list(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_describe_stack_resource(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStackResource', 'StackName': stack_name, 'LogicalResourceId': "WikiDatabase"} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResource') # Stub out the RPC call to the engine with a pre-canned response engine_resp = {u'description': u'', u'resource_identity': { u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u'resources/WikiDatabase' }, u'stack_name': u'wordpress', u'resource_name': u'WikiDatabase', u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', u'metadata': {u'wordpress': []}} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) args = { 'stack_identity': identity, 'resource_name': dummy_req.params.get('LogicalResourceId'), } rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': args, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.describe_stack_resource(dummy_req) expected = {'DescribeStackResourceResponse': {'DescribeStackResourceResult': {'StackResourceDetail': {'StackId': u'arn:openstack:heat::t:stacks/wordpress/6', 'ResourceStatus': u'CREATE_COMPLETE', 'Description': u'', 'ResourceType': u'AWS::EC2::Instance', 'ResourceStatusReason': None, 'LastUpdatedTimestamp': u'2012-07-23T13:06:00Z', 'StackName': u'wordpress', 'PhysicalResourceId': u'a3455d8c-9f88-404d-a85b-5315293e67de', 'Metadata': {u'wordpress': []}, 'LogicalResourceId': u'WikiDatabase'}}}} self.assertEqual(expected, response) def test_describe_stack_resource_nonexistent_stack(self): # Format a dummy request stack_name = "wibble" params = {'Action': 'DescribeStackResource', 'StackName': stack_name, 'LogicalResourceId': "WikiDatabase"} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResource') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.describe_stack_resource(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_describe_stack_resource_nonexistent(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStackResource', 'StackName': stack_name, 'LogicalResourceId': "wibble"} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResource') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) args = { 'stack_identity': identity, 'resource_name': dummy_req.params.get('LogicalResourceId'), } rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resource', 'args': args, 'version': self.api_version}, None).AndRaise(heat_exception.ResourceNotFound( resource_name='test', stack_name='test')) self.m.ReplayAll() result = self.controller.describe_stack_resource(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_describe_stack_resources(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStackResources', 'StackName': stack_name, 'LogicalResourceId': "WikiDatabase"} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResources') # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'description': u'', u'resource_identity': { u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u'resources/WikiDatabase' }, u'stack_name': u'wordpress', u'resource_name': u'WikiDatabase', u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', u'metadata': {u'ensureRunning': u'true''true'}}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) args = { 'stack_identity': identity, 'resource_name': dummy_req.params.get('LogicalResourceId'), } rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resources', 'args': args, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.describe_stack_resources(dummy_req) expected = {'DescribeStackResourcesResponse': {'DescribeStackResourcesResult': {'StackResources': [{'StackId': u'arn:openstack:heat::t:stacks/wordpress/6', 'ResourceStatus': u'CREATE_COMPLETE', 'Description': u'', 'ResourceType': u'AWS::EC2::Instance', 'Timestamp': u'2012-07-23T13:06:00Z', 'ResourceStatusReason': None, 'StackName': u'wordpress', 'PhysicalResourceId': u'a3455d8c-9f88-404d-a85b-5315293e67de', 'LogicalResourceId': u'WikiDatabase'}]}}} self.assertEqual(expected, response) def test_describe_stack_resources_bad_name(self): stack_name = "wibble" params = {'Action': 'DescribeStackResources', 'StackName': stack_name, 'LogicalResourceId': "WikiDatabase"} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResources') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.describe_stack_resources(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def test_describe_stack_resources_physical(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'DescribeStackResources', 'LogicalResourceId': "WikiDatabase", 'PhysicalResourceId': 'a3455d8c-9f88-404d-a85b-5315293e67de'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResources') # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'description': u'', u'resource_identity': { u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u'resources/WikiDatabase' }, u'stack_name': u'wordpress', u'resource_name': u'WikiDatabase', u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance', u'metadata': {u'ensureRunning': u'true''true'}}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'find_physical_resource', 'args': {'physical_resource_id': 'a3455d8c-9f88-404d-a85b-5315293e67de'}, 'version': self.api_version}, None).AndReturn(identity) args = { 'stack_identity': identity, 'resource_name': dummy_req.params.get('LogicalResourceId'), } rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'describe_stack_resources', 'args': args, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.describe_stack_resources(dummy_req) expected = {'DescribeStackResourcesResponse': {'DescribeStackResourcesResult': {'StackResources': [{'StackId': u'arn:openstack:heat::t:stacks/wordpress/6', 'ResourceStatus': u'CREATE_COMPLETE', 'Description': u'', 'ResourceType': u'AWS::EC2::Instance', 'Timestamp': u'2012-07-23T13:06:00Z', 'ResourceStatusReason': None, 'StackName': u'wordpress', 'PhysicalResourceId': u'a3455d8c-9f88-404d-a85b-5315293e67de', 'LogicalResourceId': u'WikiDatabase'}]}}} self.assertEqual(expected, response) def test_describe_stack_resources_physical_not_found(self): # Format a dummy request params = {'Action': 'DescribeStackResources', 'LogicalResourceId': "WikiDatabase", 'PhysicalResourceId': 'aaaaaaaa-9f88-404d-cccc-ffffffffffff'} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResources') # Stub out the RPC call to the engine with a pre-canned response self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'find_physical_resource', 'args': {'physical_resource_id': 'aaaaaaaa-9f88-404d-cccc-ffffffffffff'}, 'version': self.api_version}, None).AndRaise( heat_exception.PhysicalResourceNotFound(resource_id='1')) self.m.ReplayAll() response = self.controller.describe_stack_resources(dummy_req) self.assertIsInstance(response, exception.HeatInvalidParameterValueError) def test_describe_stack_resources_err_inval(self): # Format a dummy request containing both StackName and # PhysicalResourceId, which is invalid and should throw a # HeatInvalidParameterCombinationError stack_name = "wordpress" params = {'Action': 'DescribeStackResources', 'StackName': stack_name, 'PhysicalResourceId': "123456"} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'DescribeStackResources') ret = self.controller.describe_stack_resources(dummy_req) self.assertIsInstance(ret, exception.HeatInvalidParameterCombinationError) def test_list_stack_resources(self): # Format a dummy request stack_name = "wordpress" identity = dict(identifier.HeatIdentifier('t', stack_name, '6')) params = {'Action': 'ListStackResources', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStackResources') # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'resource_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u'/resources/WikiDatabase'}, u'stack_name': u'wordpress', u'resource_name': u'WikiDatabase', u'resource_status_reason': None, u'updated_time': u'2012-07-23T13:06:00Z', u'stack_identity': {u'tenant': u't', u'stack_name': u'wordpress', u'stack_id': u'6', u'path': u''}, u'resource_action': u'CREATE', u'resource_status': u'COMPLETE', u'physical_resource_id': u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance'}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None).AndReturn(identity) rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'list_stack_resources', 'args': {'stack_identity': identity}, 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() response = self.controller.list_stack_resources(dummy_req) expected = {'ListStackResourcesResponse': {'ListStackResourcesResult': {'StackResourceSummaries': [{'ResourceStatus': u'CREATE_COMPLETE', 'ResourceType': u'AWS::EC2::Instance', 'ResourceStatusReason': None, 'LastUpdatedTimestamp': u'2012-07-23T13:06:00Z', 'PhysicalResourceId': u'a3455d8c-9f88-404d-a85b-5315293e67de', 'LogicalResourceId': u'WikiDatabase'}]}}} self.assertEqual(expected, response) def test_list_stack_resources_bad_name(self): stack_name = "wibble" params = {'Action': 'ListStackResources', 'StackName': stack_name} dummy_req = self._dummy_GET_request(params) self._stub_enforce(dummy_req, 'ListStackResources') # Insert an engine RPC error and ensure we map correctly to the # heat exception type self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'method': 'identify_stack', 'args': {'stack_name': stack_name}, 'version': self.api_version}, None ).AndRaise(heat_exception.StackNotFound(stack_name='test')) self.m.ReplayAll() result = self.controller.list_stack_resources(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) heat-2014.1.5/heat/tests/fakes.py0000664000567000056700000001205012540642614017555 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. from heat.common import context """ A fake server that "responds" to API methods with pre-canned responses. All of these responses come from the spec, so if for some reason the spec's wrong the tests might raise AssertionError. I've indicated in comments the places where actual behavior differs from the spec. """ class FakeClient(object): def assert_called(self, method, url, body=None, pos=-1): """ Assert than an API method was just called. """ expected = (method, url) called = self.client.callstack[pos][0:2] assert self.client.callstack, \ "Expected %s %s but no calls were made." % expected assert expected == called, 'Expected %s %s; got %s %s' % \ (expected + called) if body is not None: assert self.client.callstack[pos][2] == body def assert_called_anytime(self, method, url, body=None): """ Assert than an API method was called anytime in the test. """ expected = (method, url) assert self.client.callstack, \ "Expected %s %s but no calls were made." % expected found = False for entry in self.client.callstack: if expected == entry[0:2]: found = True break assert found, 'Expected %s %s; got %s' % \ (expected, self.client.callstack) if body is not None: try: assert entry[2] == body except AssertionError: print(entry[2]) print("!=") print(body) raise self.client.callstack = [] def clear_callstack(self): self.client.callstack = [] def authenticate(self): pass class FakeKeystoneClient(object): def __init__(self, username='test_user', password='apassword', user_id='1234', access='4567', secret='8901', credential_id='abcdxyz'): self.username = username self.password = password self.user_id = user_id self.access = access self.secret = secret self.credential_id = credential_id class FakeCred(object): id = self.credential_id access = self.access secret = self.secret self.creds = FakeCred() self.auth_token = 'abcd1234' def create_stack_user(self, username, password=''): self.username = username return self.user_id def delete_stack_user(self, user_id): self.user_id = None def get_ec2_keypair(self, access, user_id): if user_id == self.user_id: if access == self.access: return self.creds else: raise ValueError("Unexpected access %s" % access) else: raise ValueError("Unexpected user_id %s" % user_id) def create_ec2_keypair(self, user_id): if user_id == self.user_id: return self.creds def delete_ec2_keypair(self, credential_id=None, user_id=None, access=None): if user_id == self.user_id and access == self.creds.access: self.creds = None else: raise Exception('Incorrect user_id or access') def enable_stack_user(self, user_id): pass def disable_stack_user(self, user_id): pass def url_for(self, **kwargs): return 'http://example.com:1234/v1' def create_trust_context(self): return context.RequestContext(username=self.username, password=self.password, is_admin=False, trust_id='atrust', trustor_user_id='auser123') def delete_trust(self, trust_id): pass def delete_stack_domain_project(self, project_id): pass def create_stack_domain_project(self, stack_id): return 'aprojectid' def create_stack_domain_user(self, username, project_id, password=None): return self.user_id def delete_stack_domain_user(self, user_id, project_id): pass def create_stack_domain_user_keypair(self, user_id, project_id): return self.creds def enable_stack_domain_user(self, user_id, project_id): pass def disable_stack_domain_user(self, user_id, project_id): pass def delete_stack_domain_user_keypair(self, user_id, project_id, credential_id): pass heat-2014.1.5/heat/tests/test_stack_lock.py0000664000567000056700000001603612540642614021650 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. from heat.common import exception from heat.db import api as db_api from heat.engine import stack_lock from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common.rpc import proxy from heat.tests.common import HeatTestCase from heat.tests import utils class StackLockTest(HeatTestCase): def setUp(self): super(StackLockTest, self).setUp() utils.setup_dummy_db() self.context = utils.dummy_context() self.stack = self.m.CreateMockAnything() self.stack.id = "aae01f2d-52ae-47ac-8a0d-3fde3d220fea" self.stack.name = "test_stack" self.stack.action = "CREATE" self.engine_id = stack_lock.StackLock.generate_engine_id() def test_successful_acquire_new_lock(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn(None) self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) slock.acquire() self.m.VerifyAll() def test_failed_acquire_existing_lock_current_engine(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn(self.engine_id) self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) self.assertRaises(exception.ActionInProgress, slock.acquire) self.m.VerifyAll() def test_successful_acquire_existing_lock_engine_dead(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id self.m.StubOutWithMock(proxy.RpcProxy, "call") rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndRaise(rpc_common.Timeout) self.m.StubOutWithMock(db_api, "stack_lock_steal") db_api.stack_lock_steal(self.stack.id, "fake-engine-id", self.engine_id).AndReturn(None) self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) slock.acquire() self.m.VerifyAll() def test_failed_acquire_existing_lock_engine_alive(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id self.m.StubOutWithMock(proxy.RpcProxy, "call") rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndReturn(True) self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) self.assertRaises(exception.ActionInProgress, slock.acquire) self.m.VerifyAll() def test_failed_acquire_existing_lock_engine_dead(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id self.m.StubOutWithMock(proxy.RpcProxy, "call") rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndRaise(rpc_common.Timeout) self.m.StubOutWithMock(db_api, "stack_lock_steal") db_api.stack_lock_steal(self.stack.id, "fake-engine-id", self.engine_id).\ AndReturn("fake-engine-id2") self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) self.assertRaises(exception.ActionInProgress, slock.acquire) self.m.VerifyAll() def test_successful_acquire_with_retry(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id self.m.StubOutWithMock(proxy.RpcProxy, "call") rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndRaise(rpc_common.Timeout) self.m.StubOutWithMock(db_api, "stack_lock_steal") db_api.stack_lock_steal(self.stack.id, "fake-engine-id", self.engine_id).\ AndReturn(True) db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndRaise(rpc_common.Timeout) db_api.stack_lock_steal(self.stack.id, "fake-engine-id", self.engine_id).\ AndReturn(None) self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) slock.acquire() self.m.VerifyAll() def test_failed_acquire_one_retry_only(self): self.m.StubOutWithMock(db_api, "stack_lock_create") db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id self.m.StubOutWithMock(proxy.RpcProxy, "call") rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndRaise(rpc_common.Timeout) self.m.StubOutWithMock(db_api, "stack_lock_steal") db_api.stack_lock_steal(self.stack.id, "fake-engine-id", self.engine_id).\ AndReturn(True) db_api.stack_lock_create(self.stack.id, self.engine_id).\ AndReturn("fake-engine-id") topic = self.stack.id rpc = proxy.RpcProxy(topic, "1.0") rpc.call(self.context, rpc.make_msg("listening"), timeout=2, topic="fake-engine-id").AndRaise(rpc_common.Timeout) db_api.stack_lock_steal(self.stack.id, "fake-engine-id", self.engine_id).\ AndReturn(True) self.m.ReplayAll() slock = stack_lock.StackLock(self.context, self.stack, self.engine_id) self.assertRaises(exception.ActionInProgress, slock.acquire) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_neutron.py0000664000567000056700000022374212540642614021231 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. import copy import mox from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import properties from heat.engine import resource from heat.engine.resources.neutron import net from heat.engine.resources.neutron.neutron import NeutronResource as qr from heat.engine.resources.neutron import provider_net from heat.engine.resources.neutron import router from heat.engine.resources.neutron import subnet from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils neutronclient = try_import('neutronclient.v2_0.client') qe = try_import('neutronclient.common.exceptions') neutron_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Parameters" : {}, "Resources" : { "network": { "Type": "OS::Neutron::Net", "Properties": { "name": "the_network", "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "shared": true, "dhcp_agent_ids": [ "28c25a04-3f73-45a7-a2b4-59e183943ddc" ] } }, "unnamed_network": { "Type": "OS::Neutron::Net" }, "admin_down_network": { "Type": "OS::Neutron::Net", "Properties": { "admin_state_up": false } }, "subnet": { "Type": "OS::Neutron::Subnet", "Properties": { "network_id": { "Ref" : "network" }, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "ip_version": 4, "cidr": "10.0.3.0/24", "allocation_pools": [{"start": "10.0.3.20", "end": "10.0.3.150"}], "host_routes": [ {"destination": "10.0.4.0/24", "nexthop": "10.0.3.20"}], "dns_nameservers": ["8.8.8.8"] } }, "port": { "Type": "OS::Neutron::Port", "Properties": { "device_id": "d6b4d3a5-c700-476f-b609-1493dd9dadc0", "name": "port1", "network_id": { "Ref" : "network" }, "fixed_ips": [{ "subnet_id": { "Ref" : "subnet" }, "ip_address": "10.0.3.21" }] } }, "port2": { "Type": "OS::Neutron::Port", "Properties": { "name": "port2", "network_id": { "Ref" : "network" } } }, "router": { "Type": "OS::Neutron::Router", "Properties": { "l3_agent_id": "792ff887-6c85-4a56-b518-23f24fa65581" } }, "router_interface": { "Type": "OS::Neutron::RouterInterface", "Properties": { "router_id": { "Ref" : "router" }, "subnet_id": { "Ref" : "subnet" } } }, "gateway": { "Type": "OS::Neutron::RouterGateway", "Properties": { "router_id": { "Ref" : "router" }, "network_id": { "Ref" : "network" } } } } } ''' provider_network_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Resources" : { "provider_network_vlan": { "Type": "OS::Neutron::ProviderNet", "Properties": { "name": "the_provider_network", "network_type": "vlan", "physical_network": "physnet_1", "segmentation_id": "101", "shared": true } } } } ''' neutron_external_gateway_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Parameters" : {}, "Resources" : { "router": { "Type": "OS::Neutron::Router", "Properties": { "name": "Test Router", "external_gateway_info": { "network": "public", "enable_snat": true } } } } } ''' neutron_floating_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Parameters" : {}, "Resources" : { "port_floating": { "Type": "OS::Neutron::Port", "Properties": { "network_id": "xyz1234", "fixed_ips": [{ "subnet_id": "sub1234", "ip_address": "10.0.0.10" }] } }, "floating_ip": { "Type": "OS::Neutron::FloatingIP", "Properties": { "floating_network_id": "abcd1234", } }, "floating_ip_assoc": { "Type": "OS::Neutron::FloatingIPAssociation", "Properties": { "floatingip_id": { "Ref" : "floating_ip" }, "port_id": { "Ref" : "port_floating" } } }, "router": { "Type": "OS::Neutron::Router" }, "gateway": { "Type": "OS::Neutron::RouterGateway", "Properties": { "router_id": { "Ref" : "router" }, "network_id": "abcd1234" } } } } ''' neutron_port_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Parameters" : {}, "Resources" : { "port": { "Type": "OS::Neutron::Port", "Properties": { "network_id": "net1234", "fixed_ips": [{ "subnet_id": "sub1234", "ip_address": "10.0.3.21" }], "device_owner": "network:dhcp" } } } } ''' neutron_port_with_address_pair_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Parameters" : {}, "Resources" : { "port": { "Type": "OS::Neutron::Port", "Properties": { "network_id": "abcd1234", "allowed_address_pairs": [{ "ip_address": "10.0.3.21", "mac_address": "00-B0-D0-86-BB-F7" }] } } } } ''' neutron_subnet_and_external_gateway_template = ''' { "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "net_external": { "Type": "OS::Neutron::Net", "Properties": { "name": "net_external", "admin_state_up": true, "value_specs": { "provider:network_type": "flat", "provider:physical_network": "default", "router:external": true } } }, "subnet_external": { "Type": "OS::Neutron::Subnet", "Properties": { "name": "subnet_external", "network_id": { "Ref": "net_external" }, "ip_version": 4, "cidr": "192.168.10.0/24", "gateway_ip": "192.168.10.11", "enable_dhcp": false } }, "router": { "Type": "OS::Neutron::Router", "Properties": { "name": "router_heat", "external_gateway_info": { "network": { "Ref": "net_external" } } } } } } ''' stpna = { "network": { "status": "ACTIVE", "subnets": [], "name": "the_provider_network", "admin_state_up": True, "shared": True, "provider:network_type": "vlan", "provider:physical_network": "physnet_1", "provider:segmentation_id": "101", "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" } } stpnb = copy.deepcopy(stpna) stpnb['network']['status'] = "BUILD" class NeutronTest(HeatTestCase): def test_validate_properties(self): vs = {'router:external': True} data = {'admin_state_up': False, 'value_specs': vs} p = properties.Properties(net.Net.properties_schema, data) self.assertIsNone(qr.validate_properties(p)) vs['shared'] = True self.assertEqual('shared not allowed in value_specs', qr.validate_properties(p)) vs.pop('shared') vs['name'] = 'foo' self.assertEqual('name not allowed in value_specs', qr.validate_properties(p)) vs.pop('name') vs['tenant_id'] = '1234' self.assertEqual('tenant_id not allowed in value_specs', qr.validate_properties(p)) vs.pop('tenant_id') vs['foo'] = '1234' self.assertIsNone(qr.validate_properties(p)) def test_prepare_properties(self): data = {'admin_state_up': False, 'value_specs': {'router:external': True}} p = properties.Properties(net.Net.properties_schema, data) props = qr.prepare_properties(p, 'resource_name') self.assertEqual({'name': 'resource_name', 'router:external': True, 'admin_state_up': False, 'shared': False}, props) def test_is_built(self): self.assertTrue(qr.is_built({ 'name': 'the_net', 'status': 'ACTIVE' })) self.assertTrue(qr.is_built({ 'name': 'the_net', 'status': 'DOWN' })) self.assertFalse(qr.is_built({ 'name': 'the_net', 'status': 'BUILD' })) self.assertRaises(exception.Error, qr.is_built, { 'name': 'the_net', 'status': 'FROBULATING' }) @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronNetTest(HeatTestCase): def setUp(self): super(NeutronNetTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_network') self.m.StubOutWithMock(neutronclient.Client, 'delete_network') self.m.StubOutWithMock(neutronclient.Client, 'show_network') self.m.StubOutWithMock(neutronclient.Client, 'update_network') self.m.StubOutWithMock(neutronclient.Client, 'add_network_to_dhcp_agent') self.m.StubOutWithMock(neutronclient.Client, 'remove_network_from_dhcp_agent') self.m.StubOutWithMock(neutronclient.Client, 'list_dhcp_agent_hosting_networks') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_net(self, t, stack, resource_name): rsrc = net.Net('test_net', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_net(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) # Create script neutronclient.Client.create_network({ 'network': { 'name': u'the_network', 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'shared': True} }).AndReturn({"network": { "status": "BUILD", "subnets": [], "name": "name", "admin_state_up": True, "shared": True, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.list_dhcp_agent_hosting_networks( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({"agents": []}) neutronclient.Client.add_network_to_dhcp_agent( '28c25a04-3f73-45a7-a2b4-59e183943ddc', {'network_id': u'fc68ea2c-b60b-4b4f-bd82-94ec81110766'} ).AndReturn(None) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({"network": { "status": "BUILD", "subnets": [], "name": "name", "admin_state_up": True, "shared": True, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({"network": { "status": "ACTIVE", "subnets": [], "name": "name", "admin_state_up": True, "shared": True, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NetworkNotFoundClient(status_code=404)) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({"network": { "status": "ACTIVE", "subnets": [], "name": "name", "admin_state_up": True, "shared": True, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({"network": { "status": "ACTIVE", "subnets": [], "name": "name", "admin_state_up": True, "shared": True, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) # Update script neutronclient.Client.list_dhcp_agent_hosting_networks( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({ "agents": [{ "admin_state_up": True, "agent_type": "DHCP agent", "alive": True, "binary": "neutron-dhcp-agent", "configurations": { "dhcp_driver": "DummyDriver", "dhcp_lease_duration": 86400, "networks": 0, "ports": 0, "subnets": 0, "use_namespaces": True}, "created_at": "2014-03-20 05:12:34", "description": None, "heartbeat_timestamp": "2014-03-20 05:12:34", "host": "hostname", "id": "28c25a04-3f73-45a7-a2b4-59e183943ddc", "started_at": "2014-03-20 05:12:34", "topic": "dhcp_agent" }] }) neutronclient.Client.add_network_to_dhcp_agent( 'bb09cfcd-5277-473d-8336-d4ed8628ae68', {'network_id': u'fc68ea2c-b60b-4b4f-bd82-94ec81110766'} ).AndReturn(None) neutronclient.Client.remove_network_from_dhcp_agent( '28c25a04-3f73-45a7-a2b4-59e183943ddc', 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(None) neutronclient.Client.update_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {'network': { 'shared': True, 'name': 'mynet', 'admin_state_up': True }}).AndReturn(None) # Delete script neutronclient.Client.delete_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(None) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NetworkNotFoundClient(status_code=404)) neutronclient.Client.delete_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NetworkNotFoundClient(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_net(t, stack, 'network') # assert the implicit dependency between the gateway and the interface deps = stack.dependencies[stack['router_interface']] self.assertIn(stack['gateway'], deps) # assert the implicit dependency between the gateway and the subnet deps = stack.dependencies[stack['subnet']] self.assertIn(stack['gateway'], deps) rsrc.validate() ref_id = rsrc.FnGetRefId() self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', ref_id) self.assertIsNone(rsrc.FnGetAtt('status')) self.assertEqual('ACTIVE', rsrc.FnGetAtt('status')) self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') update_snippet = { "Type": "OS::Neutron::Net", "Properties": { "name": "mynet", "shared": True, "admin_state_up": True, "dhcp_agent_ids": [ "bb09cfcd-5277-473d-8336-d4ed8628ae68" ] } } prop_diff = { "name": "mynet", "dhcp_agent_ids": [ "bb09cfcd-5277-473d-8336-d4ed8628ae68" ] } rsrc.handle_update(update_snippet, {}, prop_diff) scheduler.TaskRunner(rsrc.delete)() rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronProviderNetTest(HeatTestCase): def setUp(self): super(NeutronProviderNetTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_network') self.m.StubOutWithMock(neutronclient.Client, 'show_network') self.m.StubOutWithMock(neutronclient.Client, 'delete_network') self.m.StubOutWithMock(neutronclient.Client, 'update_network') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_provider_net(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) # Create script neutronclient.Client.create_network({ 'network': { 'name': u'the_provider_network', 'admin_state_up': True, 'provider:network_type': 'vlan', 'provider:physical_network': 'physnet_1', 'provider:segmentation_id': '101', 'shared': True} }).AndReturn(stpnb) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(stpnb) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(stpna) t = template_format.parse(provider_network_template) stack = utils.parse_stack(t) rsrc = provider_net.ProviderNet( 'provider_net', t['Resources']['provider_network_vlan'], stack) return rsrc def test_create_provider_net(self): rsrc = self.create_provider_net() neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NetworkNotFoundClient(status_code=404)) # Delete script neutronclient.Client.delete_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(None) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(stpna) neutronclient.Client.show_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NetworkNotFoundClient(status_code=404)) neutronclient.Client.delete_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NetworkNotFoundClient(status_code=404)) self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) ref_id = rsrc.FnGetRefId() self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', ref_id) self.assertIsNone(rsrc.FnGetAtt('status')) self.assertEqual('ACTIVE', rsrc.FnGetAtt('status')) self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_update_provider_net(self): rsrc = self.create_provider_net() neutronclient.Client.update_network( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {'network': { 'shared': True, 'name': 'prov_net', 'admin_state_up': True, 'provider:network_type': 'vlan', 'provider:physical_network': 'physnet_1', 'provider:segmentation_id': '102' }}).AndReturn(None) self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) update_snippet = { "Type": "OS::Neutron::ProviderNet", "Properties": { "name": "prov_net", "shared": True, "admin_state_up": True, "network_type": "vlan", "physical_network": "physnet_1", "segmentation_id": "102" } } self.assertIsNone(rsrc.handle_update(update_snippet, {}, {})) self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronSubnetTest(HeatTestCase): def setUp(self): super(NeutronSubnetTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_subnet') self.m.StubOutWithMock(neutronclient.Client, 'delete_subnet') self.m.StubOutWithMock(neutronclient.Client, 'show_subnet') self.m.StubOutWithMock(neutronclient.Client, 'update_subnet') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_subnet(self, t, stack, resource_name): rsrc = subnet.Subnet('test_subnet', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_subnet(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_subnet({ 'subnet': { 'name': utils.PhysName('test_stack', 'test_subnet'), 'network_id': u'None', 'dns_nameservers': [u'8.8.8.8'], 'allocation_pools': [ {'start': u'10.0.3.20', 'end': u'10.0.3.150'}], 'host_routes': [ {'destination': u'10.0.4.0/24', 'nexthop': u'10.0.3.20'}], 'ip_version': 4, 'cidr': u'10.0.3.0/24', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'enable_dhcp': True } }).AndReturn({ "subnet": { "allocation_pools": [ {"start": "10.0.3.20", "end": "10.0.3.150"}], "cidr": "10.0.3.0/24", "dns_nameservers": ["8.8.8.8"], "enable_dhcp": True, "gateway_ip": "10.0.3.1", "host_routes": [ {"destination": "10.0.4.0/24", "nexthop": "10.0.3.20"}], "id": "91e47a57-7508-46fe-afc9-fc454e8580e1", "ip_version": 4, "name": "name", "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "tenant_id": "c1210485b2424d48804aad5d39c61b8f" } }) neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1').AndRaise( qe.NeutronClientException(status_code=404)) sn = { "subnet": { "name": "name", "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "allocation_pools": [ {"start": "10.0.3.20", "end": "10.0.3.150"}], "gateway_ip": "10.0.3.1", 'host_routes': [ {'destination': u'10.0.4.0/24', 'nexthop': u'10.0.3.20'}], "ip_version": 4, "cidr": "10.0.3.0/24", "dns_nameservers": ["8.8.8.8"], "id": "91e47a57-7508-46fe-afc9-fc454e8580e1", "enable_dhcp": True, } } neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1').AndReturn(sn) neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1').AndReturn(sn) neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1').AndReturn(sn) # Update script neutronclient.Client.update_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1', {'subnet': { 'dns_nameservers': ['8.8.8.8', '192.168.1.254'], 'name': 'mysubnet', 'enable_dhcp': True }} ) # Delete script neutronclient.Client.delete_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1' ).AndReturn(None) neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1' ).AndRaise(qe.NeutronClientException(status_code=404)) neutronclient.Client.delete_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_subnet(t, stack, 'subnet') rsrc.validate() ref_id = rsrc.FnGetRefId() self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id) self.assertIsNone(rsrc.FnGetAtt('network_id')) self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', rsrc.FnGetAtt('network_id')) self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0]) # assert the dependency (implicit or explicit) between the ports # and the subnet self.assertIn(stack['port'], stack.dependencies[stack['subnet']]) self.assertIn(stack['port2'], stack.dependencies[stack['subnet']]) update_snippet = { "Type": "OS::Neutron::Subnet", "Properties": { "name": 'mysubnet', "network_id": {"Ref": "network"}, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "ip_version": 4, "cidr": "10.0.3.0/24", "allocation_pools": [ {"start": "10.0.3.20", "end": "10.0.3.150"}], "dns_nameservers": ["8.8.8.8", "192.168.1.254"], 'host_routes': [ {'destination': u'10.0.4.0/24', 'nexthop': u'10.0.3.20'}] } } rsrc.handle_update(stack.resolve_static_data(update_snippet), {}, {}) self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) self.m.VerifyAll() def test_subnet_disable_dhcp(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_subnet({ 'subnet': { 'name': utils.PhysName('test_stack', 'test_subnet'), 'network_id': u'None', 'dns_nameservers': [u'8.8.8.8'], 'allocation_pools': [ {'start': u'10.0.3.20', 'end': u'10.0.3.150'}], 'host_routes': [ {'destination': u'10.0.4.0/24', 'nexthop': u'10.0.3.20'}], 'ip_version': 4, 'enable_dhcp': False, 'cidr': u'10.0.3.0/24', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f' } }).AndReturn({ "subnet": { "allocation_pools": [ {"start": "10.0.3.20", "end": "10.0.3.150"}], "host_routes": [ {"destination": "10.0.4.0/24", "nexthop": "10.0.3.20"}], "cidr": "10.0.3.0/24", "dns_nameservers": ["8.8.8.8"], "enable_dhcp": False, "gateway_ip": "10.0.3.1", "id": "91e47a57-7508-46fe-afc9-fc454e8580e1", "ip_version": 4, "name": "name", "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "tenant_id": "c1210485b2424d48804aad5d39c61b8f" } }) neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1').AndReturn({ "subnet": { "name": "name", "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "allocation_pools": [ {"start": "10.0.3.20", "end": "10.0.3.150"}], "host_routes": [ {"destination": "10.0.4.0/24", "nexthop": "10.0.3.20"}], "gateway_ip": "10.0.3.1", "ip_version": 4, "cidr": "10.0.3.0/24", "dns_nameservers": ["8.8.8.8"], "id": "91e47a57-7508-46fe-afc9-fc454e8580e1", "enable_dhcp": False, } }) neutronclient.Client.delete_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1' ).AndReturn(None) neutronclient.Client.show_subnet( '91e47a57-7508-46fe-afc9-fc454e8580e1' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) t['Resources']['subnet']['Properties']['enable_dhcp'] = 'False' stack = utils.parse_stack(t) rsrc = self.create_subnet(t, stack, 'subnet') rsrc.validate() ref_id = rsrc.FnGetRefId() self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id) self.assertIs(False, rsrc.FnGetAtt('enable_dhcp')) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_null_gateway_ip(self): p = {} subnet.Subnet._null_gateway_ip(p) self.assertEqual({}, p) p = {'foo': 'bar'} subnet.Subnet._null_gateway_ip(p) self.assertEqual({'foo': 'bar'}, p) p = { 'foo': 'bar', 'gateway_ip': '198.51.100.0' } subnet.Subnet._null_gateway_ip(p) self.assertEqual({ 'foo': 'bar', 'gateway_ip': '198.51.100.0' }, p) p = { 'foo': 'bar', 'gateway_ip': '' } subnet.Subnet._null_gateway_ip(p) self.assertEqual({ 'foo': 'bar', 'gateway_ip': None }, p) # This should not happen as prepare_properties # strips out None values, but testing anyway p = { 'foo': 'bar', 'gateway_ip': None } subnet.Subnet._null_gateway_ip(p) self.assertEqual({ 'foo': 'bar', 'gateway_ip': None }, p) @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronRouterTest(HeatTestCase): @skipIf(router.neutronV20 is None, "Missing Neutron v2_0") def setUp(self): super(NeutronRouterTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_router') self.m.StubOutWithMock(neutronclient.Client, 'delete_router') self.m.StubOutWithMock(neutronclient.Client, 'show_router') self.m.StubOutWithMock(neutronclient.Client, 'update_router') self.m.StubOutWithMock(neutronclient.Client, 'add_interface_router') self.m.StubOutWithMock(neutronclient.Client, 'remove_interface_router') self.m.StubOutWithMock(neutronclient.Client, 'add_gateway_router') self.m.StubOutWithMock(neutronclient.Client, 'remove_gateway_router') self.m.StubOutWithMock(neutronclient.Client, 'add_router_to_l3_agent') self.m.StubOutWithMock(neutronclient.Client, 'remove_router_from_l3_agent') self.m.StubOutWithMock(neutronclient.Client, 'list_l3_agent_hosting_routers') self.m.StubOutWithMock(router.neutronV20, 'find_resourceid_by_name_or_id') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_router(self, t, stack, resource_name): rsrc = router.Router('router', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_router_interface(self, t, stack, resource_name, properties={}): t['Resources'][resource_name]['Properties'] = properties rsrc = router.RouterInterface( 'router_interface', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_gateway_router(self, t, stack, resource_name, properties={}): t['Resources'][resource_name]['Properties'] = properties rsrc = router.RouterGateway( 'gateway', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_router(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_router({ 'router': { 'name': utils.PhysName('test_stack', 'router'), 'admin_state_up': True, } }).AndReturn({ "router": { "status": "BUILD", "external_gateway_info": None, "name": utils.PhysName('test_stack', 'router'), "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) neutronclient.Client.list_l3_agent_hosting_routers( u'3e46229d-8fce-4733-819a-b5fe630550f8' ).AndReturn({"agents": []}) neutronclient.Client.add_router_to_l3_agent( u'792ff887-6c85-4a56-b518-23f24fa65581', {'router_id': u'3e46229d-8fce-4733-819a-b5fe630550f8'} ).AndReturn(None) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "BUILD", "external_gateway_info": None, "name": utils.PhysName('test_stack', 'router'), "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": None, "name": utils.PhysName('test_stack', 'router'), "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndRaise( qe.NeutronClientException(status_code=404)) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": None, "name": utils.PhysName('test_stack', 'router'), "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": None, "name": utils.PhysName('test_stack', 'router'), "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) # Update script neutronclient.Client.list_l3_agent_hosting_routers( u'3e46229d-8fce-4733-819a-b5fe630550f8' ).AndReturn({ "agents": [{ "admin_state_up": True, "agent_type": "L3 agent", "alive": True, "binary": "neutron-l3-agent", "configurations": { "ex_gw_ports": 1, "floating_ips": 0, "gateway_external_network_id": "", "handle_internal_only_routers": True, "interface_driver": "DummyDriver", "interfaces": 1, "router_id": "", "routers": 1, "use_namespaces": True}, "created_at": "2014-03-11 05:00:05", "description": None, "heartbeat_timestamp": "2014-03-11 05:01:49", "host": "l3_agent_host", "id": "792ff887-6c85-4a56-b518-23f24fa65581", "started_at": "2014-03-11 05:00:05", "topic": "l3_agent" }] }) neutronclient.Client.remove_router_from_l3_agent( u'792ff887-6c85-4a56-b518-23f24fa65581', u'3e46229d-8fce-4733-819a-b5fe630550f8' ).AndReturn(None) neutronclient.Client.add_router_to_l3_agent( u'63b3fd83-2c5f-4dad-b3ae-e0f83a40f216', {'router_id': u'3e46229d-8fce-4733-819a-b5fe630550f8'} ).AndReturn(None) neutronclient.Client.update_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'router': { 'name': 'myrouter', 'admin_state_up': False }} ) # Delete script neutronclient.Client.delete_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndReturn(None) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndRaise(qe.NeutronClientException(status_code=404)) neutronclient.Client.delete_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_router(t, stack, 'router') rsrc.validate() ref_id = rsrc.FnGetRefId() self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8', ref_id) self.assertIsNone(rsrc.FnGetAtt('tenant_id')) self.assertEqual('3e21026f2dc94372b105808c0e721661', rsrc.FnGetAtt('tenant_id')) update_snippet = { "Type": "OS::Neutron::Router", "Properties": { "admin_state_up": False, "name": "myrouter", "l3_agent_id": "63b3fd83-2c5f-4dad-b3ae-e0f83a40f216" } } prop_diff = { "admin_state_up": False, "name": "myrouter", "l3_agent_id": "63b3fd83-2c5f-4dad-b3ae-e0f83a40f216" } rsrc.handle_update(update_snippet, {}, prop_diff) self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) self.m.VerifyAll() def test_router_dependence(self): # assert the implicit dependency between the router # and subnet t = template_format.parse( neutron_subnet_and_external_gateway_template) stack = utils.parse_stack(t) deps = stack.dependencies[stack['subnet_external']] self.assertIn(stack['router'], deps) def test_router_interface(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.add_interface_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'} ).AndReturn(None) neutronclient.Client.remove_interface_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'} ).AndReturn(None) neutronclient.Client.remove_interface_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'} ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_router_interface( t, stack, 'router_interface', properties={ 'router_id': '3e46229d-8fce-4733-819a-b5fe630550f8', 'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1' }) scheduler.TaskRunner(rsrc.delete)() rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_router_interface_with_old_data(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.add_interface_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'} ).AndReturn(None) neutronclient.Client.remove_interface_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'} ).AndReturn(None) neutronclient.Client.remove_interface_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'} ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_router_interface( t, stack, 'router_interface', properties={ 'router_id': '3e46229d-8fce-4733-819a-b5fe630550f8', 'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1' }) self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8' ':subnet_id=91e47a57-7508-46fe-afc9-fc454e8580e1', rsrc.resource_id) (rsrc.resource_id) = ('3e46229d-8fce-4733-819a-b5fe630550f8:' '91e47a57-7508-46fe-afc9-fc454e8580e1') scheduler.TaskRunner(rsrc.delete)() self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8' ':91e47a57-7508-46fe-afc9-fc454e8580e1', rsrc.resource_id) rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_router_interface_with_port_id(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.add_interface_router( 'ae478782-53c0-4434-ab16-49900c88016c', {'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'} ).AndReturn(None) neutronclient.Client.remove_interface_router( 'ae478782-53c0-4434-ab16-49900c88016c', {'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'} ).AndReturn(None) neutronclient.Client.remove_interface_router( 'ae478782-53c0-4434-ab16-49900c88016c', {'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'} ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_router_interface( t, stack, 'router_interface', properties={ 'router_id': 'ae478782-53c0-4434-ab16-49900c88016c', 'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e' }) scheduler.TaskRunner(rsrc.delete)() rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_router_interface_validate(self): t = template_format.parse(neutron_template) json = t['Resources']['router_interface'] json['Properties'] = { 'router_id': 'ae478782-53c0-4434-ab16-49900c88016c', 'subnet_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e', 'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'} stack = utils.parse_stack(t) res = router.RouterInterface('router_interface', json, stack) self.assertRaises(exception.ResourcePropertyConflict, res.validate) json['Properties'] = { 'router_id': 'ae478782-53c0-4434-ab16-49900c88016c', 'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'} stack = utils.parse_stack(t) res = router.RouterInterface('router_interface', json, stack) self.assertIsNone(res.validate()) json['Properties'] = { 'router_id': 'ae478782-53c0-4434-ab16-49900c88016c', 'subnet_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'} stack = utils.parse_stack(t) res = router.RouterInterface('router_interface', json, stack) self.assertIsNone(res.validate()) json['Properties'] = { 'router_id': 'ae478782-53c0-4434-ab16-49900c88016c'} stack = utils.parse_stack(t) res = router.RouterInterface('router_interface', json, stack) ex = self.assertRaises(exception.StackValidationFailed, res.validate) self.assertEqual("Either subnet_id or port_id must be specified.", str(ex)) def test_gateway_router(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) router.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'network', 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766') neutronclient.Client.add_gateway_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'} ).AndReturn(None) neutronclient.Client.remove_gateway_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndReturn(None) neutronclient.Client.remove_gateway_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_template) stack = utils.parse_stack(t) rsrc = self.create_gateway_router( t, stack, 'gateway', properties={ 'router_id': '3e46229d-8fce-4733-819a-b5fe630550f8', 'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' }) scheduler.TaskRunner(rsrc.delete)() rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def _create_router_with_gateway(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) router.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'network', 'public' ).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766') neutronclient.Client.create_router({ "router": { "name": "Test Router", "external_gateway_info": { 'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', 'enable_snat': True }, "admin_state_up": True, } }).AndReturn({ "router": { "status": "BUILD", "external_gateway_info": None, "name": "Test Router", "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": { "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "enable_snat": True }, "name": "Test Router", "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) def test_create_router_gateway_as_property(self): self._create_router_with_gateway() neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": { "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "enable_snat": True }, "name": "Test Router", "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) self.m.ReplayAll() t = template_format.parse(neutron_external_gateway_template) stack = utils.parse_stack(t) rsrc = self.create_router(t, stack, 'router') rsrc.validate() ref_id = rsrc.FnGetRefId() self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8', ref_id) gateway_info = rsrc.FnGetAtt('external_gateway_info') self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', gateway_info.get('network_id')) self.assertTrue(gateway_info.get('enable_snat')) self.m.VerifyAll() def test_create_router_gateway_enable_snat(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) router.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'network', 'public' ).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766') neutronclient.Client.create_router({ "router": { "name": "Test Router", "external_gateway_info": { 'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', }, "admin_state_up": True, } }).AndReturn({ "router": { "status": "BUILD", "external_gateway_info": None, "name": "Test Router", "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').MultipleTimes().AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": { "network_id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "enable_snat": True }, "name": "Test Router", "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) self.m.ReplayAll() t = template_format.parse(neutron_external_gateway_template) t["Resources"]["router"]["Properties"]["external_gateway_info"].pop( "enable_snat") stack = utils.parse_stack(t) rsrc = self.create_router(t, stack, 'router') rsrc.validate() ref_id = rsrc.FnGetRefId() self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8', ref_id) gateway_info = rsrc.FnGetAtt('external_gateway_info') self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', gateway_info.get('network_id')) self.m.VerifyAll() def test_update_router_gateway_as_property(self): self._create_router_with_gateway() router.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'network', 'other_public' ).AndReturn('91e47a57-7508-46fe-afc9-fc454e8580e1') neutronclient.Client.update_router( '3e46229d-8fce-4733-819a-b5fe630550f8', {'router': { "name": "Test Router", "external_gateway_info": { 'network_id': '91e47a57-7508-46fe-afc9-fc454e8580e1', 'enable_snat': False }, "admin_state_up": True}} ).AndReturn(None) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({ "router": { "status": "ACTIVE", "external_gateway_info": { "network_id": "91e47a57-7508-46fe-afc9-fc454e8580e1", "enable_snat": False }, "name": "Test Router", "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "3e46229d-8fce-4733-819a-b5fe630550f8" } }) self.m.ReplayAll() t = template_format.parse(neutron_external_gateway_template) stack = utils.parse_stack(t) rsrc = self.create_router(t, stack, 'router') update_template = copy.deepcopy(rsrc.t) update_template['Properties']['external_gateway_info'] = { "network": "other_public", "enable_snat": False } scheduler.TaskRunner(rsrc.update, update_template)() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) gateway_info = rsrc.FnGetAtt('external_gateway_info') self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', gateway_info.get('network_id')) self.assertFalse(gateway_info.get('enable_snat')) self.m.VerifyAll() def test_delete_router_gateway_as_property(self): self._create_router_with_gateway() neutronclient.Client.delete_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndReturn(None) neutronclient.Client.show_router( '3e46229d-8fce-4733-819a-b5fe630550f8' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_external_gateway_template) stack = utils.parse_stack(t) rsrc = self.create_router(t, stack, 'router') self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronFloatingIPTest(HeatTestCase): @skipIf(net.clients.neutronclient is None, "Missing Neutron Client") def setUp(self): super(NeutronFloatingIPTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_floatingip') self.m.StubOutWithMock(neutronclient.Client, 'delete_floatingip') self.m.StubOutWithMock(neutronclient.Client, 'show_floatingip') self.m.StubOutWithMock(neutronclient.Client, 'update_floatingip') self.m.StubOutWithMock(neutronclient.Client, 'create_port') self.m.StubOutWithMock(neutronclient.Client, 'delete_port') self.m.StubOutWithMock(neutronclient.Client, 'update_port') self.m.StubOutWithMock(neutronclient.Client, 'show_port') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def test_floating_ip(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_floatingip({ 'floatingip': {'floating_network_id': u'abcd1234'} }).AndReturn({'floatingip': { 'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', 'floating_network_id': u'abcd1234' }}) neutronclient.Client.show_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NeutronClientException(status_code=404)) neutronclient.Client.show_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).MultipleTimes().AndReturn({'floatingip': { 'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', 'floating_network_id': u'abcd1234' }}) neutronclient.Client.delete_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None) neutronclient.Client.delete_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise( qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_floating_template) stack = utils.parse_stack(t) # assert the implicit dependency between the floating_ip # and the gateway deps = stack.dependencies[stack['gateway']] self.assertIn(stack['floating_ip'], deps) fip = stack['floating_ip'] scheduler.TaskRunner(fip.create)() self.assertEqual((fip.CREATE, fip.COMPLETE), fip.state) fip.validate() fip_id = fip.FnGetRefId() self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', fip_id) self.assertIsNone(fip.FnGetAtt('show')) self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', fip.FnGetAtt('show')['id']) self.assertRaises(exception.InvalidTemplateAttribute, fip.FnGetAtt, 'Foo') self.assertEqual(u'abcd1234', fip.FnGetAtt('floating_network_id')) self.assertRaises(resource.UpdateReplace, fip.handle_update, {}, {}, {}) scheduler.TaskRunner(fip.delete)() fip.state_set(fip.CREATE, fip.COMPLETE, 'to delete again') scheduler.TaskRunner(fip.delete)() self.m.VerifyAll() def test_port(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'xyz1234', 'fixed_ips': [ {'subnet_id': u'sub1234', 'ip_address': u'10.0.0.10'} ], 'name': utils.PhysName('test_stack', 'port_floating'), 'admin_state_up': True}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.PortNotFoundClient(status_code=404)) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).MultipleTimes().AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.update_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', { 'port': { 'fixed_ips': [ {'subnet_id': 'sub1234', 'ip_address': '10.0.0.11'} ], 'admin_state_up': True, 'name': 'test_port', 'device_id': 'd6b4d3a5-c700-476f-b609-1493dd9dadc2', 'device_owner': 'network:floatingip' } } ).AndReturn(None) self.m.ReplayAll() t = template_format.parse(neutron_floating_template) stack = utils.parse_stack(t) p = stack['port_floating'] scheduler.TaskRunner(p.create)() self.assertEqual((p.CREATE, p.COMPLETE), p.state) p.validate() port_id = p.FnGetRefId() self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', port_id) self.assertIsNone(p.FnGetAtt('status')) self.assertEqual('ACTIVE', p.FnGetAtt('status')) self.assertRaises( exception.InvalidTemplateAttribute, p.FnGetAtt, 'Foo') self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', p.resource_id) update_snippet = { "Type": "OS::Neutron::Port", "Properties": { "network_id": "xyz1234", "fixed_ips": [{ "subnet_id": "sub1234", "ip_address": "10.0.0.11" }], "name": "test_port", "device_id": "d6b4d3a5-c700-476f-b609-1493dd9dadc2", 'device_owner': 'network:floatingip' } } p.handle_update(update_snippet, {}, {}) self.m.VerifyAll() def test_floatip_port(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_floatingip({ 'floatingip': {'floating_network_id': u'abcd1234'} }).AndReturn({'floatingip': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.create_port({'port': { 'network_id': u'xyz1234', 'fixed_ips': [ {'subnet_id': u'sub1234', 'ip_address': u'10.0.0.10'} ], 'name': utils.PhysName('test_stack', 'port_floating'), 'admin_state_up': True}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.update_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', { 'floatingip': { 'port_id': u'fc68ea2c-b60b-4b4f-bd82-94ec81110766'}} ).AndReturn({'floatingip': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.update_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {'floatingip': { 'port_id': None }}).AndReturn(None) neutronclient.Client.delete_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(None) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.PortNotFoundClient(status_code=404)) neutronclient.Client.delete_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn(None) neutronclient.Client.update_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {'floatingip': { 'port_id': None }}).AndRaise(qe.NeutronClientException(status_code=404)) neutronclient.Client.delete_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.PortNotFoundClient(status_code=404)) neutronclient.Client.delete_floatingip( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() t = template_format.parse(neutron_floating_template) stack = utils.parse_stack(t) fip = stack['floating_ip'] scheduler.TaskRunner(fip.create)() self.assertEqual((fip.CREATE, fip.COMPLETE), fip.state) p = stack['port_floating'] scheduler.TaskRunner(p.create)() self.assertEqual((p.CREATE, p.COMPLETE), p.state) fipa = stack['floating_ip_assoc'] scheduler.TaskRunner(fipa.create)() self.assertEqual((fipa.CREATE, fipa.COMPLETE), fipa.state) fipa.validate() fipa_id = fipa.FnGetRefId() fip_id = fip.FnGetRefId() port_id = p.FnGetRefId() self.assertEqual('%s:%s' % (fip_id, port_id), fipa_id) self.assertRaises(resource.UpdateReplace, fipa.handle_update, {}, {}, {}) scheduler.TaskRunner(fipa.delete)() scheduler.TaskRunner(p.delete)() scheduler.TaskRunner(fip.delete)() fipa.state_set(fipa.CREATE, fipa.COMPLETE, 'to delete again') fip.state_set(fip.CREATE, fip.COMPLETE, 'to delete again') p.state_set(p.CREATE, p.COMPLETE, 'to delete again') scheduler.TaskRunner(fipa.delete)() self.assertIsNone(scheduler.TaskRunner(p.delete)()) scheduler.TaskRunner(fip.delete)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronPortTest(HeatTestCase): @skipIf(net.clients.neutronclient is None, "Missing Neutron Client") def setUp(self): super(NeutronPortTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_port') self.m.StubOutWithMock(neutronclient.Client, 'show_port') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def test_missing_subnet_id(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'net1234', 'fixed_ips': [ {'ip_address': u'10.0.3.21'} ], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp'}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) self.m.ReplayAll() t = template_format.parse(neutron_port_template) t['Resources']['port']['Properties']['fixed_ips'][0].pop('subnet_id') stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll() def test_missing_ip_address(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'net1234', 'fixed_ips': [ {'subnet_id': u'sub1234'} ], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp'}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) self.m.ReplayAll() t = template_format.parse(neutron_port_template) t['Resources']['port']['Properties']['fixed_ips'][0].pop('ip_address') stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll() def test_missing_fixed_ips(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'net1234', 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp'}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766", "fixed_ips": { "subnet_id": "d0e971a6-a6b4-4f4c-8c88-b75e9c120b7e", "ip_address": "10.0.0.2" } }}) self.m.ReplayAll() t = template_format.parse(neutron_port_template) t['Resources']['port']['Properties'].pop('fixed_ips') stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll() def test_allowed_address_pair(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'abcd1234', 'allowed_address_pairs': [{ 'ip_address': u'10.0.3.21', 'mac_address': u'00-B0-D0-86-BB-F7' }], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) self.m.ReplayAll() t = template_format.parse(neutron_port_with_address_pair_template) stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll() def test_missing_mac_address(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'abcd1234', 'allowed_address_pairs': [{ 'ip_address': u'10.0.3.21', }], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) self.m.ReplayAll() t = template_format.parse(neutron_port_with_address_pair_template) t['Resources']['port']['Properties']['allowed_address_pairs'][0].pop( 'mac_address' ) stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll() def test_security_groups(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_port({'port': { 'network_id': u'net1234', 'security_groups': ['8a2f582a-e1cd-480f-b85d-b02631c10656', '024613dc-b489-4478-b46f-ada462738740'], 'fixed_ips': [ {'subnet_id': u'sub1234', 'ip_address': u'10.0.3.21'} ], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp'}} ).AndReturn({'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766' ).AndReturn({'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" }}) self.m.ReplayAll() t = template_format.parse(neutron_port_template) t['Resources']['port']['Properties']['security_groups'] = [ '8a2f582a-e1cd-480f-b85d-b02631c10656', '024613dc-b489-4478-b46f-ada462738740'] stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class NetworkConstraintTest(HeatTestCase): def test_validate(self): self.m.StubOutWithMock(clients.OpenStackClients, 'neutron') clients.OpenStackClients.neutron().MultipleTimes().AndReturn(None) self.m.StubOutWithMock(net.neutronV20, 'find_resourceid_by_name_or_id') net.neutronV20.find_resourceid_by_name_or_id( None, 'network', 'foo' ).AndReturn('foo') net.neutronV20.find_resourceid_by_name_or_id( None, 'network', 'bar' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() constraint = net.NetworkConstraint() self.assertTrue(constraint.validate("foo", None)) self.assertFalse(constraint.validate("bar", None)) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_api_openstack_v1_util.py0000664000567000056700000001027712540642614024017 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. import mock from webob import exc from heat.api.openstack.v1 import util from heat.common import context from heat.common import policy from heat.common.wsgi import Request from heat.tests.common import HeatTestCase class TestGetAllowedParams(HeatTestCase): def setUp(self): super(TestGetAllowedParams, self).setUp() req = Request({}) self.params = req.params.copy() self.params.add('foo', 'foo value') self.whitelist = {'foo': 'single'} def test_returns_empty_dict(self): self.whitelist = {} result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual({}, result) def test_only_adds_whitelisted_params_if_param_exists(self): self.whitelist = {'foo': 'single'} self.params.clear() result = util.get_allowed_params(self.params, self.whitelist) self.assertNotIn('foo', result) def test_returns_only_whitelisted_params(self): self.params.add('bar', 'bar value') result = util.get_allowed_params(self.params, self.whitelist) self.assertIn('foo', result) self.assertNotIn('bar', result) def test_handles_single_value_params(self): result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual('foo value', result['foo']) def test_handles_multiple_value_params(self): self.whitelist = {'foo': 'multi'} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo']) def test_handles_mixed_value_param_with_multiple_entries(self): self.whitelist = {'foo': 'mixed'} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo']) def test_handles_mixed_value_param_with_single_entry(self): self.whitelist = {'foo': 'mixed'} result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual('foo value', result['foo']) def test_ignores_bogus_whitelist_items(self): self.whitelist = {'foo': 'blah'} result = util.get_allowed_params(self.params, self.whitelist) self.assertNotIn('foo', result) class TestPolicyEnforce(HeatTestCase): def setUp(self): super(TestPolicyEnforce, self).setUp() self.req = Request({}) self.req.context = context.RequestContext(tenant_id='foo', is_admin=False) class DummyController(object): REQUEST_SCOPE = 'test' @util.policy_enforce def an_action(self, req): return 'woot' self.controller = DummyController() @mock.patch.object(policy.Enforcer, 'enforce') def test_policy_enforce_tenant_mismatch(self, mock_enforce): mock_enforce.return_value = True self.assertEqual('woot', self.controller.an_action(self.req, 'foo')) self.assertRaises(exc.HTTPForbidden, self.controller.an_action, self.req, tenant_id='bar') @mock.patch.object(policy.Enforcer, 'enforce') def test_policy_enforce_policy_deny(self, mock_enforce): mock_enforce.return_value = False self.assertRaises(exc.HTTPForbidden, self.controller.an_action, self.req, tenant_id='foo') heat-2014.1.5/heat/tests/test_loadbalancer.py0000664000567000056700000002236612540642614022145 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. import re import mock import mox from oslo.config import cfg from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.resource import Metadata from heat.engine.resources import instance from heat.engine.resources import loadbalancer as lb from heat.engine.resources import wait_condition as wc from heat.engine import scheduler from heat.engine import stack_user from heat.tests.common import HeatTestCase from heat.tests import fakes as test_fakes from heat.tests import utils from heat.tests.v1_1 import fakes lb_template = ''' { "AWSTemplateFormatVersion": "2010-09-09", "Description": "LB Template", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources": { "WikiServerOne": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "F17-x86_64-gold", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "some data" } }, "LoadBalancer" : { "Type" : "AWS::ElasticLoadBalancing::LoadBalancer", "Properties" : { "AvailabilityZones" : ["nova"], "Instances" : [{"Ref": "WikiServerOne"}], "Listeners" : [ { "LoadBalancerPort" : "80", "InstancePort" : "80", "Protocol" : "HTTP" }] } } } } ''' lb_template_nokey = ''' { "AWSTemplateFormatVersion": "2010-09-09", "Description": "LB Template", "Resources": { "WikiServerOne": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId": "F17-x86_64-gold", "InstanceType" : "m1.large", "UserData" : "some data" } }, "LoadBalancer" : { "Type" : "AWS::ElasticLoadBalancing::LoadBalancer", "Properties" : { "AvailabilityZones" : ["nova"], "Instances" : [{"Ref": "WikiServerOne"}], "Listeners" : [ { "LoadBalancerPort" : "80", "InstancePort" : "80", "Protocol" : "HTTP" }] } } } } ''' class LoadBalancerTest(HeatTestCase): def setUp(self): super(LoadBalancerTest, self).setUp() self.fc = fakes.FakeClient() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(self.fc.servers, 'create') self.m.StubOutWithMock(Metadata, '__set__') self.fkc = test_fakes.FakeKeystoneClient( username='test_stack.CfnLBUser') cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') utils.setup_dummy_db() def create_loadbalancer(self, t, stack, resource_name): rsrc = lb.LoadBalancer(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def _create_stubs(self, key_name='test', stub_meta=True): self.m.StubOutWithMock(stack_user.StackUser, 'keystone') stack_user.StackUser.keystone().MultipleTimes().AndReturn(self.fkc) server_name = utils.PhysName( utils.PhysName('test_stack', 'LoadBalancer'), 'LB_instance', limit=instance.Instance.physical_resource_name_limit) clients.OpenStackClients.nova( "compute").MultipleTimes().AndReturn(self.fc) clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.fc.servers.create( flavor=2, image=746, key_name=key_name, meta=None, nics=None, name=server_name, scheduler_hints=None, userdata=mox.IgnoreArg(), security_groups=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) if stub_meta: Metadata.__set__(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(None) self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status') wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) def test_loadbalancer(self): self._create_stubs() self.m.ReplayAll() t = template_format.parse(lb_template) s = utils.parse_stack(t) s.store() rsrc = self.create_loadbalancer(t, s, 'LoadBalancer') hc = { 'Target': 'HTTP:80/', 'HealthyThreshold': '3', 'UnhealthyThreshold': '5', 'Interval': '30', 'Timeout': '5'} rsrc.t['Properties']['HealthCheck'] = hc self.assertIsNone(rsrc.validate()) hc['Timeout'] = 35 self.assertEqual( {'Error': 'Interval must be larger than Timeout'}, rsrc.validate()) hc['Timeout'] = 5 self.assertEqual('LoadBalancer', rsrc.FnGetRefId()) templ = template_format.parse(lb.lb_template_default) ha_cfg = rsrc._haproxy_config(templ, rsrc.properties['Instances']) self.assertRegexpMatches(ha_cfg, 'bind \*:80') self.assertRegexpMatches(ha_cfg, 'server server1 1\.2\.3\.4:80 ' 'check inter 30s fall 5 rise 3') self.assertRegexpMatches(ha_cfg, 'timeout check 5s') id_list = [] for inst_name in ['WikiServerOne1', 'WikiServerOne2']: inst = instance.Instance(inst_name, s.t['Resources']['WikiServerOne'], s) id_list.append(inst.FnGetRefId()) rsrc.handle_update(rsrc.json_snippet, {}, {'Instances': id_list}) self.assertEqual('4.5.6.7', rsrc.FnGetAtt('DNSName')) self.assertEqual('', rsrc.FnGetAtt('SourceSecurityGroup.GroupName')) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertIsNone(rsrc.handle_update({}, {}, {})) self.m.VerifyAll() def test_loadbalancer_nokey(self): self._create_stubs(key_name=None, stub_meta=False) self.m.ReplayAll() t = template_format.parse(lb_template_nokey) s = utils.parse_stack(t) s.store() rsrc = self.create_loadbalancer(t, s, 'LoadBalancer') self.assertEqual('LoadBalancer', rsrc.name) self.m.VerifyAll() def assertRegexpMatches(self, text, expected_regexp, msg=None): """Fail the test unless the text matches the regular expression.""" if isinstance(expected_regexp, basestring): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(text): msg = msg or "Regexp didn't match" msg = '%s: %r not found in %r' % (msg, expected_regexp.pattern, text) raise self.failureException(msg) def test_loadbalancer_validate_badtemplate(self): cfg.CONF.set_override('loadbalancer_template', '/a/noexist/x.y') t = template_format.parse(lb_template) s = utils.parse_stack(t) s.store() rsrc = lb.LoadBalancer('LoadBalancer', t['Resources']['LoadBalancer'], s) self.assertRaises(exception.StackValidationFailed, rsrc.validate) def setup_loadbalancer(self, include_keyname=True): template = template_format.parse(lb_template) if not include_keyname: del template['Parameters']['KeyName'] stack = utils.parse_stack(template) resource_name = 'LoadBalancer' lb_json = template['Resources'][resource_name] return lb.LoadBalancer(resource_name, lb_json, stack) def test_child_params_without_key_name(self): rsrc = self.setup_loadbalancer(False) self.assertEqual({}, rsrc.child_params()) def test_child_params_with_key_name(self): rsrc = self.setup_loadbalancer() params = rsrc.child_params() self.assertEqual('test', params['KeyName']) def test_child_template_without_key_name(self): rsrc = self.setup_loadbalancer(False) parsed_template = { 'Resources': {'LB_instance': {'Properties': {'KeyName': 'foo'}}}, 'Parameters': {'KeyName': 'foo'} } rsrc.get_parsed_template = mock.Mock(return_value=parsed_template) tmpl = rsrc.child_template() self.assertNotIn('KeyName', tmpl['Parameters']) self.assertNotIn('KeyName', tmpl['Resources']['LB_instance']['Properties']) def test_child_template_with_key_name(self): rsrc = self.setup_loadbalancer() rsrc.get_parsed_template = mock.Mock(return_value='foo') self.assertEqual('foo', rsrc.child_template()) heat-2014.1.5/heat/tests/test_template.py0000664000567000056700000001211412540642614021337 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # 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. from heat.common import exception from heat.engine.cfn.template import CfnTemplate from heat.engine import plugin_manager from heat.engine import template from heat.tests.common import HeatTestCase class TestTemplatePluginManager(HeatTestCase): def test_pkg_name(self): cfn_tmpl_pkg = template.TemplatePluginManager.package_name(CfnTemplate) self.assertEqual('heat.engine.cfn', cfn_tmpl_pkg) def test_get(self): tpm = template.TemplatePluginManager() self.assertFalse(tpm.plugin_managers) class Test(object): plugins = tpm test_pm = Test().plugins self.assertTrue(isinstance(test_pm, plugin_manager.PluginManager)) self.assertEqual(tpm.plugin_managers['heat.tests'], test_pm) class TestTemplateVersion(HeatTestCase): versions = (('heat_template_version', '2013-05-23'), ('HeatTemplateFormatVersion', '2012-12-12'), ('AWSTemplateFormatVersion', '2010-09-09')) def test_hot_version(self): tmpl = { 'heat_template_version': '2013-05-23', 'foo': 'bar', 'parameters': {} } self.assertEqual(('heat_template_version', '2013-05-23'), template.get_version(tmpl, self.versions)) def test_cfn_version(self): tmpl = { 'AWSTemplateFormatVersion': '2010-09-09', 'foo': 'bar', 'Parameters': {} } self.assertEqual(('AWSTemplateFormatVersion', '2010-09-09'), template.get_version(tmpl, self.versions)) def test_heat_cfn_version(self): tmpl = { 'HeatTemplateFormatVersion': '2012-12-12', 'foo': 'bar', 'Parameters': {} } self.assertEqual(('HeatTemplateFormatVersion', '2012-12-12'), template.get_version(tmpl, self.versions)) def test_missing_version(self): tmpl = { 'foo': 'bar', 'Parameters': {} } self.assertEqual(('HeatTemplateFormatVersion', '2012-12-12'), template.get_version(tmpl, self.versions)) def test_ambiguous_version(self): tmpl = { 'AWSTemplateFormatVersion': '2010-09-09', 'HeatTemplateFormatVersion': '2012-12-12', 'foo': 'bar', 'Parameters': {} } self.assertRaises(exception.InvalidTemplateVersion, template.get_version, tmpl, self.versions) class TestTemplateValidate(HeatTestCase): def test_template_validate_cfn_good(self): t = { 'AWSTemplateFormatVersion': '2010-09-09', 'Description': 'foo', 'Parameters': {}, 'Mappings': {}, 'Resources': {}, 'Outputs': {}, } tmpl = template.Template(t) err = tmpl.validate() self.assertIsNone(err) # test with alternate version key t = { 'HeatTemplateFormatVersion': '2012-12-12', 'Description': 'foo', 'Parameters': {}, 'Mappings': {}, 'Resources': {}, 'Outputs': {}, } tmpl = template.Template(t) err = tmpl.validate() self.assertIsNone(err) def test_template_validate_cfn_bad_section(self): t = { 'AWSTemplateFormatVersion': '2010-09-09', 'Description': 'foo', 'Parameteers': {}, 'Mappings': {}, 'Resources': {}, 'Outputs': {}, } tmpl = template.Template(t) err = self.assertRaises(exception.InvalidTemplateSection, tmpl.validate) self.assertIn('Parameteers', str(err)) def test_template_validate_hot_good(self): t = { 'heat_template_version': '2013-05-23', 'description': 'foo', 'parameters': {}, 'resources': {}, 'outputs': {}, } tmpl = template.Template(t) err = tmpl.validate() self.assertIsNone(err) def test_template_validate_hot_bad_section(self): t = { 'heat_template_version': '2013-05-23', 'description': 'foo', 'parameteers': {}, 'resources': {}, 'outputs': {}, } tmpl = template.Template(t) err = self.assertRaises(exception.InvalidTemplateSection, tmpl.validate) self.assertIn('parameteers', str(err)) heat-2014.1.5/heat/tests/policy/0000775000567000056700000000000012540643116017411 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/policy/check_admin.json0000664000567000056700000000005212540642611022525 0ustar jenkinsjenkins00000000000000{ "context_is_admin": "role:admin" } heat-2014.1.5/heat/tests/policy/deny_stack_user.json0000664000567000056700000000260412540642611023467 0ustar jenkinsjenkins00000000000000{ "deny_stack_user": "not role:heat_stack_user", "cloudformation:ListStacks": "rule:deny_stack_user", "cloudformation:CreateStack": "rule:deny_stack_user", "cloudformation:DescribeStacks": "rule:deny_stack_user", "cloudformation:DeleteStack": "rule:deny_stack_user", "cloudformation:UpdateStack": "rule:deny_stack_user", "cloudformation:DescribeStackEvents": "rule:deny_stack_user", "cloudformation:ValidateTemplate": "rule:deny_stack_user", "cloudformation:GetTemplate": "rule:deny_stack_user", "cloudformation:EstimateTemplateCost": "rule:deny_stack_user", "cloudformation:DescribeStackResource": "", "cloudformation:DescribeStackResources": "rule:deny_stack_user", "cloudformation:ListStackResources": "rule:deny_stack_user", "cloudwatch:DeleteAlarms": "rule:deny_stack_user", "cloudwatch:DescribeAlarmHistory": "rule:deny_stack_user", "cloudwatch:DescribeAlarms": "rule:deny_stack_user", "cloudwatch:DescribeAlarmsForMetric": "rule:deny_stack_user", "cloudwatch:DisableAlarmActions": "rule:deny_stack_user", "cloudwatch:EnableAlarmActions": "rule:deny_stack_user", "cloudwatch:GetMetricStatistics": "rule:deny_stack_user", "cloudwatch:ListMetrics": "rule:deny_stack_user", "cloudwatch:PutMetricAlarm": "rule:deny_stack_user", "cloudwatch:PutMetricData": "", "cloudwatch:SetAlarmState": "rule:deny_stack_user" } heat-2014.1.5/heat/tests/policy/notallowed.json0000664000567000056700000000101312540642611022446 0ustar jenkinsjenkins00000000000000{ "cloudformation:ListStacks": "!", "cloudformation:CreateStack": "!", "cloudformation:DescribeStacks": "!", "cloudformation:DeleteStack": "!", "cloudformation:UpdateStack": "!", "cloudformation:DescribeStackEvents": "!", "cloudformation:ValidateTemplate": "!", "cloudformation:GetTemplate": "!", "cloudformation:EstimateTemplateCost": "!", "cloudformation:DescribeStackResource": "!", "cloudformation:DescribeStackResources": "!", "cloudformation:ListStackResources": "!" } heat-2014.1.5/heat/tests/test_nested_stack.py0000664000567000056700000005411512540642614022202 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. import copy import json import mock from requests import exceptions from oslo.config import cfg cfg.CONF.import_opt('max_resources_per_stack', 'heat.common.config') from heat.common import exception from heat.common import template_format from heat.common import urlfetch from heat.db import api as db_api from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import utils class NestedStackTest(HeatTestCase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: https://server.test/the.template Parameters: KeyName: foo ''' nested_template = ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Outputs: Foo: Value: bar ''' update_template = ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Outputs: Bar: Value: foo ''' def setUp(self): super(NestedStackTest, self).setUp() self.m.StubOutWithMock(urlfetch, 'get') utils.setup_dummy_db() def create_stack(self, template): t = template_format.parse(template) stack = self.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) return stack def adopt_stack(self, template, adopt_data): t = template_format.parse(template) stack = self.parse_stack(t, adopt_data) stack.adopt() self.assertEqual((stack.ADOPT, stack.COMPLETE), stack.state) return stack def parse_stack(self, t, data=None): ctx = utils.dummy_context('test_username', 'aaaa', 'password') stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(ctx, stack_name, tmpl, adopt_stack_data=data) stack.store() return stack def test_nested_stack_create(self): urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) rsrc = stack['the_nested'] nested_name = utils.PhysName(stack.name, 'the_nested') self.assertEqual(rsrc.physical_resource_name(), nested_name) arn_prefix = ('arn:openstack:heat::aaaa:stacks/%s/' % rsrc.physical_resource_name()) self.assertTrue(rsrc.FnGetRefId().startswith(arn_prefix)) self.assertEqual('bar', rsrc.FnGetAtt('Outputs.Foo')) self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Outputs.Bar') self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Bar') rsrc.delete() self.assertTrue(rsrc.FnGetRefId().startswith(arn_prefix)) self.m.VerifyAll() def test_nested_stack_adopt(self): resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() adopt_data = { "resources": { "the_nested": { "resource_id": "test-res-id", "resources": { "NestedResource": { "resource_id": "test-nested-res-id" } } } } } stack = self.adopt_stack(self.test_template, adopt_data) self.assertEqual((stack.ADOPT, stack.COMPLETE), stack.state) rsrc = stack['the_nested'] self.assertEqual((rsrc.ADOPT, rsrc.COMPLETE), rsrc.state) nested_name = utils.PhysName(stack.name, 'the_nested') self.assertEqual(nested_name, rsrc.physical_resource_name()) self.assertEqual('test-nested-res-id', rsrc.nested()['NestedResource'].resource_id) rsrc.delete() self.m.VerifyAll() def test_nested_stack_adopt_fail(self): resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() adopt_data = { "resources": { "the_nested": { "resource_id": "test-res-id", "resources": { } } } } stack = self.adopt_stack(self.test_template, adopt_data) rsrc = stack['the_nested'] self.assertEqual((rsrc.ADOPT, rsrc.FAILED), rsrc.nested().state) nested_name = utils.PhysName(stack.name, 'the_nested') self.assertEqual(nested_name, rsrc.physical_resource_name()) rsrc.delete() self.m.VerifyAll() def test_nested_stack_create_with_timeout(self): urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) self.m.ReplayAll() timeout_template = template_format.parse( copy.deepcopy(self.test_template)) props = timeout_template['Resources']['the_nested']['Properties'] props['TimeoutInMinutes'] = '50' stack = self.create_stack(json.dumps(timeout_template)) self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) self.m.VerifyAll() def test_nested_stack_create_exceeds_resource_limit(self): cfg.CONF.set_override('max_resources_per_stack', 1) resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() t = template_format.parse(self.test_template) stack = self.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.FAILED), stack.state) self.assertIn('Maximum resources per stack exceeded', stack.status_reason) self.m.VerifyAll() def test_nested_stack_create_equals_resource_limit(self): cfg.CONF.set_override('max_resources_per_stack', 2) resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() t = template_format.parse(self.test_template) stack = self.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) self.assertIn('NestedResource', stack['the_nested'].nested()) self.m.VerifyAll() def test_nested_stack_update(self): urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) urlfetch.get('https://server.test/new.template').MultipleTimes().\ AndReturn(self.update_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) rsrc = stack['the_nested'] original_nested_id = rsrc.resource_id t = template_format.parse(self.test_template) new_res = copy.deepcopy(t['Resources']['the_nested']) new_res['Properties']['TemplateURL'] = ( 'https://server.test/new.template') prop_diff = {'TemplateURL': 'https://server.test/new.template'} updater = rsrc.handle_update(new_res, {}, prop_diff) updater.run_to_completion() self.assertIs(True, rsrc.check_update_complete(updater)) # Expect the physical resource name staying the same after update, # so that the nested was actually updated instead of replaced. self.assertEqual(original_nested_id, rsrc.resource_id) db_nested = db_api.stack_get(stack.context, rsrc.resource_id) # Owner_id should be preserved during the update process. self.assertEqual(stack.id, db_nested.owner_id) self.assertEqual('foo', rsrc.FnGetAtt('Outputs.Bar')) self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Outputs.Foo') self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Bar') rsrc.delete() self.m.VerifyAll() def test_nested_stack_update_equals_resource_limit(self): resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) urlfetch.get('https://server.test/new.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Bar: Value: foo ''') self.m.ReplayAll() stack = self.create_stack(self.test_template) cfg.CONF.set_override('max_resources_per_stack', 2) rsrc = stack['the_nested'] t = template_format.parse(self.test_template) new_res = copy.deepcopy(t['Resources']['the_nested']) new_res['Properties']['TemplateURL'] = ( 'https://server.test/new.template') prop_diff = {'TemplateURL': 'https://server.test/new.template'} updater = rsrc.handle_update(new_res, {}, prop_diff) updater.run_to_completion() self.assertIs(True, rsrc.check_update_complete(updater)) self.assertEqual('foo', rsrc.FnGetAtt('Outputs.Bar')) rsrc.delete() self.m.VerifyAll() def test_nested_stack_update_exceeds_limit(self): resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) urlfetch.get('https://server.test/new.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Bar: Value: foo ''') self.m.ReplayAll() stack = self.create_stack(self.test_template) cfg.CONF.set_override('max_resources_per_stack', 1) rsrc = stack['the_nested'] t = template_format.parse(self.test_template) new_res = copy.deepcopy(t['Resources']['the_nested']) new_res['Properties']['TemplateURL'] = ( 'https://server.test/new.template') prop_diff = {'TemplateURL': 'https://server.test/new.template'} ex = self.assertRaises(exception.RequestLimitExceeded, rsrc.handle_update, new_res, {}, prop_diff) self.assertIn(exception.StackResourceLimitExceeded.msg_fmt, str(ex)) rsrc.delete() self.m.VerifyAll() def test_nested_stack_suspend_resume(self): urlfetch.get('https://server.test/the.template').AndReturn( self.nested_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) rsrc = stack['the_nested'] scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() def test_nested_stack_three_deep(self): root_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth1.template' ''' depth1_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth2.template' ''' depth2_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth3.template' Parameters: KeyName: foo ''' urlfetch.get( 'https://server.test/depth1.template').AndReturn( depth1_template) urlfetch.get( 'https://server.test/depth2.template').AndReturn( depth2_template) urlfetch.get( 'https://server.test/depth3.template').AndReturn( self.nested_template) self.m.ReplayAll() self.create_stack(root_template) self.m.VerifyAll() def test_nested_stack_four_deep(self): root_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth1.template' ''' depth1_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth2.template' ''' depth2_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth3.template' ''' depth3_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth4.template' Parameters: KeyName: foo ''' urlfetch.get( 'https://server.test/depth1.template').AndReturn( depth1_template) urlfetch.get( 'https://server.test/depth2.template').AndReturn( depth2_template) urlfetch.get( 'https://server.test/depth3.template').AndReturn( depth3_template) urlfetch.get( 'https://server.test/depth4.template').AndReturn( self.nested_template) self.m.ReplayAll() t = template_format.parse(root_template) stack = self.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.FAILED), stack.state) self.assertIn('Recursion depth exceeds', stack.status_reason) self.m.VerifyAll() def test_nested_stack_four_wide(self): root_template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth1.template' Parameters: KeyName: foo Nested2: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth2.template' Parameters: KeyName: foo Nested3: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth3.template' Parameters: KeyName: foo Nested4: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/depth4.template' Parameters: KeyName: foo ''' urlfetch.get( 'https://server.test/depth1.template').InAnyOrder().AndReturn( self.nested_template) urlfetch.get( 'https://server.test/depth2.template').InAnyOrder().AndReturn( self.nested_template) urlfetch.get( 'https://server.test/depth3.template').InAnyOrder().AndReturn( self.nested_template) urlfetch.get( 'https://server.test/depth4.template').InAnyOrder().AndReturn( self.nested_template) self.m.ReplayAll() self.create_stack(root_template) self.m.VerifyAll() def test_nested_stack_infinite_recursion(self): template = ''' HeatTemplateFormatVersion: 2012-12-12 Resources: Nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: 'https://server.test/the.template' ''' urlfetch.get( 'https://server.test/the.template').MultipleTimes().AndReturn( template) self.m.ReplayAll() t = template_format.parse(template) stack = self.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.FAILED), stack.state) self.assertIn('Recursion depth exceeds', stack.status_reason) self.m.VerifyAll() def test_nested_stack_delete(self): urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) rsrc = stack['the_nested'] scheduler.TaskRunner(rsrc.delete)() self.assertEqual((stack.DELETE, stack.COMPLETE), rsrc.state) nested_stack = parser.Stack.load(utils.dummy_context( 'test_username', 'aaaa', 'password'), rsrc.resource_id) self.assertEqual((stack.DELETE, stack.COMPLETE), nested_stack.state) self.m.VerifyAll() def test_nested_stack_delete_then_delete_parent_stack(self): urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(self.nested_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) rsrc = stack['the_nested'] nested_stack = parser.Stack.load(utils.dummy_context( 'test_username', 'aaaa', 'password'), rsrc.resource_id) nested_stack.delete() stack = parser.Stack.load(utils.dummy_context( 'test_username', 'aaaa', 'password'), stack.id) stack.delete() self.assertEqual((stack.DELETE, stack.COMPLETE), stack.state) self.m.VerifyAll() def test_child_params(self): t = template_format.parse(self.test_template) stack = self.parse_stack(t) nested_stack = stack['the_nested'] nested_stack.properties.data[nested_stack.PARAMETERS] = {'foo': 'bar'} self.assertEqual({'foo': 'bar'}, nested_stack.child_params()) @mock.patch.object(urlfetch, 'get') def test_child_template_when_file_is_fetched(self, mock_get): mock_get.return_value = 'template_file' t = template_format.parse(self.test_template) stack = self.parse_stack(t) nested_stack = stack['the_nested'] with mock.patch('heat.common.template_format.parse') as mock_parse: mock_parse.return_value = 'child_template' self.assertEqual('child_template', nested_stack.child_template()) mock_parse.assert_called_once_with('template_file') @mock.patch.object(urlfetch, 'get') def test_child_template_when_fetching_file_fails(self, mock_get): mock_get.side_effect = exceptions.RequestException() t = template_format.parse(self.test_template) stack = self.parse_stack(t) nested_stack = stack['the_nested'] self.assertRaises(ValueError, nested_stack.child_template) @mock.patch.object(urlfetch, 'get') def test_child_template_when_io_error(self, mock_get): mock_get.side_effect = IOError() t = template_format.parse(self.test_template) stack = self.parse_stack(t) nested_stack = stack['the_nested'] self.assertRaises(ValueError, nested_stack.child_template) class ResDataResource(generic_rsrc.GenericResource): def handle_create(self): db_api.resource_data_set(self, "test", 'A secret value', True) class ResDataNestedStackTest(NestedStackTest): nested_template = ''' HeatTemplateFormatVersion: "2012-12-12" Parameters: KeyName: Type: String Resources: nested_res: Type: "res.data.resource" Outputs: Foo: Value: bar ''' def setUp(self): super(ResDataNestedStackTest, self).setUp() resource._register_class("res.data.resource", ResDataResource) def test_res_data_delete(self): urlfetch.get('https://server.test/the.template').AndReturn( self.nested_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) res = stack['the_nested'].nested()['nested_res'] stack.delete() self.assertEqual((stack.DELETE, stack.COMPLETE), stack.state) self.assertRaises(exception.NotFound, db_api.resource_data_get, res, 'test') heat-2014.1.5/heat/tests/test_cw_alarm.py0000664000567000056700000001170412540642614021315 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. import copy from heat.common import template_format from heat.engine import resource from heat.engine.resources import cloud_watch from heat.engine import scheduler from heat.engine import watchrule from heat.tests.common import HeatTestCase from heat.tests import utils alarm_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Alarm Test", "Parameters" : {}, "Resources" : { "MEMAlarmHigh": { "Type": "AWS::CloudWatch::Alarm", "Properties": { "AlarmDescription": "Scale-up if MEM > 50% for 1 minute", "MetricName": "MemoryUtilization", "Namespace": "system/linux", "Statistic": "Average", "Period": "60", "EvaluationPeriods": "1", "Threshold": "50", "AlarmActions": [], "Dimensions": [], "ComparisonOperator": "GreaterThanThreshold" } } } } ''' class CloudWatchAlarmTest(HeatTestCase): def setUp(self): super(CloudWatchAlarmTest, self).setUp() utils.setup_dummy_db() def create_alarm(self, t, stack, resource_name): rsrc = cloud_watch.CloudWatchAlarm(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_mem_alarm_high_update_no_replace(self): ''' Make sure that we can change the update-able properties without replacing the Alarm rsrc. ''' t = template_format.parse(alarm_template) #short circuit the alarm's references properties = t['Resources']['MEMAlarmHigh']['Properties'] properties['AlarmActions'] = ['a'] properties['Dimensions'] = [{'a': 'v'}] stack = utils.parse_stack(t) # the watch rule needs a valid stack_id stack.store() self.m.ReplayAll() rsrc = self.create_alarm(t, stack, 'MEMAlarmHigh') snippet = copy.deepcopy(rsrc.parsed_template()) snippet['Properties']['ComparisonOperator'] = 'LessThanThreshold' snippet['Properties']['AlarmDescription'] = 'fruity' snippet['Properties']['EvaluationPeriods'] = '2' snippet['Properties']['Period'] = '90' snippet['Properties']['Statistic'] = 'Maximum' snippet['Properties']['Threshold'] = '39' scheduler.TaskRunner(rsrc.update, snippet)() scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_mem_alarm_high_update_replace(self): ''' Make sure that the Alarm resource IS replaced when non-update-able properties are changed. ''' t = template_format.parse(alarm_template) #short circuit the alarm's references properties = t['Resources']['MEMAlarmHigh']['Properties'] properties['AlarmActions'] = ['a'] properties['Dimensions'] = [{'a': 'v'}] stack = utils.parse_stack(t) # the watch rule needs a valid stack_id stack.store() self.m.ReplayAll() rsrc = self.create_alarm(t, stack, 'MEMAlarmHigh') snippet = copy.deepcopy(rsrc.parsed_template()) snippet['Properties']['MetricName'] = 'temp' updater = scheduler.TaskRunner(rsrc.update, snippet) self.assertRaises(resource.UpdateReplace, updater) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_suspend_resume(self): t = template_format.parse(alarm_template) stack = utils.parse_stack(t) # the watch rule needs a valid stack_id stack.store() self.m.ReplayAll() rsrc = self.create_alarm(t, stack, 'MEMAlarmHigh') scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) self.ctx = utils.dummy_context() wr = watchrule.WatchRule.load( self.ctx, watch_name="test_stack-MEMAlarmHigh") self.assertEqual(watchrule.WatchRule.SUSPENDED, wr.state) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) wr = watchrule.WatchRule.load( self.ctx, watch_name="test_stack-MEMAlarmHigh") self.assertEqual(watchrule.WatchRule.NODATA, wr.state) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_instance_network.py0000664000567000056700000002447512540642614023116 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. import uuid from heat.common import template_format from heat.engine import clients from heat.engine import environment from heat.engine import parser from heat.engine.resources import instance as instances from heat.engine.resources import network_interface as network_interfaces from heat.engine.resources import nova_utils from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes wp_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" }, "InstanceType": { "Type": "String", "Description": "EC2 instance type", "Default": "m1.small", "AllowedValues": [ "m1.small", "m1.large" ] }, "SubnetId": { "Type" : "String", "Description" : "SubnetId of an existing subnet in your VPC" }, }, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : { "Ref" : "InstanceType" }, "SubnetId" : { "Ref" : "SubnetId" }, "KeyName" : { "Ref" : "KeyName" }, "UserData" : "wordpress" } } } } ''' wp_template_with_nic = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" }, "InstanceType": { "Type": "String", "Description": "EC2 instance type", "Default": "m1.small", "AllowedValues": [ "m1.small", "m1.large" ] }, "SubnetId": { "Type" : "String", "Description" : "SubnetId of an existing subnet in your VPC" }, }, "Resources" : { "nic1": { "Type": "AWS::EC2::NetworkInterface", "Properties": { "SubnetId": { "Ref": "SubnetId" } } }, "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : { "Ref" : "InstanceType" }, "NetworkInterfaces": [ { "NetworkInterfaceId" : {"Ref": "nic1"}, "DeviceIndex" : "0" } ], "KeyName" : { "Ref" : "KeyName" }, "UserData" : "wordpress" } } } } ''' class FakeNeutron(object): def show_subnet(self, subnet, **_params): return { 'subnet': { 'name': 'name', 'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'allocation_pools': [{'start': '10.10.0.2', 'end': '10.10.0.254'}], 'gateway_ip': '10.10.0.1', 'ip_version': 4, 'cidr': '10.10.0.0/24', 'id': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861', 'enable_dhcp': False, }} def create_port(self, body=None): return { 'port': { 'admin_state_up': True, 'device_id': '', 'device_owner': '', 'fixed_ips': [{ 'ip_address': '10.0.3.3', 'subnet_id': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'}], 'id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251', 'mac_address': 'fa:16:3e:25:32:5d', 'name': '', 'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', 'status': 'ACTIVE', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f' }} class instancesTest(HeatTestCase): def setUp(self): super(instancesTest, self).setUp() self.fc = fakes.FakeClient() utils.setup_dummy_db() def _create_test_instance(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template) template = parser.Template(t) kwargs = {'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment(kwargs), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(instance, 'neutron') instance.neutron().MultipleTimes().AndReturn(FakeNeutron()) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251'}], availability_zone=None).AndReturn( return_server) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() return instance def _create_test_instance_with_nic(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template_with_nic) template = parser.Template(t) kwargs = {'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment(kwargs), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' nic = network_interfaces.NetworkInterface('%s_nic' % name, t['Resources']['nic1'], stack) instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(nic, 'neutron') nic.neutron().MultipleTimes().AndReturn(FakeNeutron()) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) nic.t = nic.stack.resolve_runtime_data(nic.t) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251'}], availability_zone=None).AndReturn( return_server) self.m.ReplayAll() # create network interface scheduler.TaskRunner(nic.create)() stack["nic1"] = nic scheduler.TaskRunner(instance.create)() return instance def test_instance_create(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance(return_server, 'in_create') # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() def test_instance_create_with_nic(self): return_server = self.fc.servers.list()[1] instance = self._create_test_instance_with_nic( return_server, 'in_create_wnic') # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_vpc.py0000664000567000056700000006706612540642614020334 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. from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils try: from neutronclient.common.exceptions import NeutronClientException from neutronclient.v2_0 import client as neutronclient except ImportError: neutronclient = None class VPCTestBase(HeatTestCase): @skipIf(neutronclient is None, 'neutronclient unavaialble') def setUp(self): super(VPCTestBase, self).setUp() utils.setup_dummy_db() self.m.StubOutWithMock(neutronclient.Client, 'add_interface_router') self.m.StubOutWithMock(neutronclient.Client, 'add_gateway_router') self.m.StubOutWithMock(neutronclient.Client, 'create_network') self.m.StubOutWithMock(neutronclient.Client, 'create_port') self.m.StubOutWithMock(neutronclient.Client, 'create_router') self.m.StubOutWithMock(neutronclient.Client, 'create_subnet') self.m.StubOutWithMock(neutronclient.Client, 'delete_network') self.m.StubOutWithMock(neutronclient.Client, 'delete_port') self.m.StubOutWithMock(neutronclient.Client, 'delete_router') self.m.StubOutWithMock(neutronclient.Client, 'delete_subnet') self.m.StubOutWithMock(neutronclient.Client, 'list_networks') self.m.StubOutWithMock(neutronclient.Client, 'list_routers') self.m.StubOutWithMock(neutronclient.Client, 'remove_gateway_router') self.m.StubOutWithMock(neutronclient.Client, 'remove_interface_router') self.m.StubOutWithMock(neutronclient.Client, 'show_subnet') self.m.StubOutWithMock(neutronclient.Client, 'show_network') self.m.StubOutWithMock(neutronclient.Client, 'show_port') self.m.StubOutWithMock(neutronclient.Client, 'show_router') self.m.StubOutWithMock(neutronclient.Client, 'create_security_group') self.m.StubOutWithMock(neutronclient.Client, 'show_security_group') self.m.StubOutWithMock(neutronclient.Client, 'list_security_groups') self.m.StubOutWithMock(neutronclient.Client, 'delete_security_group') self.m.StubOutWithMock( neutronclient.Client, 'create_security_group_rule') self.m.StubOutWithMock( neutronclient.Client, 'delete_security_group_rule') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') def create_stack(self, template): t = template_format.parse(template) stack = self.parse_stack(t) self.assertIsNone(stack.create()) return stack def parse_stack(self, t): stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, tmpl) stack.store() return stack def mock_keystone(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) def mock_create_network(self): self.vpc_name = utils.PhysName('test_stack', 'the_vpc') neutronclient.Client.create_network( { 'network': {'name': self.vpc_name} }).AndReturn({'network': { 'status': 'BUILD', 'subnets': [], 'name': 'name', 'admin_state_up': True, 'shared': False, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'aaaa' }}) neutronclient.Client.show_network( 'aaaa' ).AndReturn({"network": { "status": "BUILD", "subnets": [], "name": self.vpc_name, "admin_state_up": False, "shared": False, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "aaaa" }}) neutronclient.Client.show_network( 'aaaa' ).MultipleTimes().AndReturn({"network": { "status": "ACTIVE", "subnets": [], "name": self.vpc_name, "admin_state_up": False, "shared": False, "tenant_id": "c1210485b2424d48804aad5d39c61b8f", "id": "aaaa" }}) neutronclient.Client.create_router( {'router': {'name': self.vpc_name}}).AndReturn({ 'router': { 'status': 'BUILD', 'name': self.vpc_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'bbbb' }}) neutronclient.Client.list_routers(name=self.vpc_name).AndReturn({ "routers": [{ "status": "BUILD", "external_gateway_info": None, "name": self.vpc_name, "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "bbbb" }] }) self.mock_router_for_vpc() def mock_create_subnet(self): self.subnet_name = utils.PhysName('test_stack', 'the_subnet') neutronclient.Client.create_subnet( {'subnet': { 'network_id': u'aaaa', 'cidr': u'10.0.0.0/24', 'ip_version': 4, 'name': self.subnet_name}}).AndReturn({ 'subnet': { 'status': 'ACTIVE', 'name': self.subnet_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'cccc'}}) self.mock_router_for_vpc() neutronclient.Client.add_interface_router( u'bbbb', {'subnet_id': 'cccc'}).AndReturn(None) def mock_show_subnet(self): neutronclient.Client.show_subnet('cccc').AndReturn({ 'subnet': { 'name': self.subnet_name, 'network_id': 'aaaa', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'allocation_pools': [{'start': '10.0.0.2', 'end': '10.0.0.254'}], 'gateway_ip': '10.0.0.1', 'ip_version': 4, 'cidr': '10.0.0.0/24', 'id': 'cccc', 'enable_dhcp': False, }}) def mock_create_security_group(self): self.sg_name = utils.PhysName('test_stack', 'the_sg') neutronclient.Client.create_security_group({ 'security_group': { 'name': self.sg_name, 'description': 'SSH access' } }).AndReturn({ 'security_group': { 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'name': self.sg_name, 'description': 'SSH access', 'security_group_rules': [], 'id': '0389f747-7785-4757-b7bb-2ab07e4b09c3' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': '0389f747-7785-4757-b7bb-2ab07e4b09c3' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': '0389f747-7785-4757-b7bb-2ab07e4b09c3', 'id': 'bbbb' } }) def mock_show_security_group(self, group=None): sg_name = utils.PhysName('test_stack', 'the_sg') group = group or '0389f747-7785-4757-b7bb-2ab07e4b09c3' if group == '0389f747-7785-4757-b7bb-2ab07e4b09c3': neutronclient.Client.show_security_group(group).AndReturn({ 'security_group': { 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'name': sg_name, 'description': '', 'security_group_rules': [{ 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'bbbb', 'ethertype': 'IPv4', 'security_group_id': ('0389f747-7785-4757-b7bb-' '2ab07e4b09c3'), 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'port_range_min': '22' }], 'id': '0389f747-7785-4757-b7bb-2ab07e4b09c3'}}) elif group == 'INVALID-NO-REF': neutronclient.Client.show_security_group(group).AndRaise( NeutronClientException(status_code=404)) elif group == 'RaiseException': neutronclient.Client.show_security_group( '0389f747-7785-4757-b7bb-2ab07e4b09c3').AndRaise( NeutronClientException(status_code=403)) def mock_delete_security_group(self): self.mock_show_security_group() neutronclient.Client.delete_security_group_rule( 'bbbb').AndReturn(None) neutronclient.Client.delete_security_group( '0389f747-7785-4757-b7bb-2ab07e4b09c3').AndReturn(None) def mock_router_for_vpc(self): neutronclient.Client.list_routers(name=self.vpc_name).AndReturn({ "routers": [{ "status": "ACTIVE", "external_gateway_info": { "network_id": "zzzz", "enable_snat": True}, "name": self.vpc_name, "admin_state_up": True, "tenant_id": "3e21026f2dc94372b105808c0e721661", "routes": [], "id": "bbbb" }] }) def mock_delete_network(self): self.mock_router_for_vpc() neutronclient.Client.delete_router('bbbb').AndReturn(None) neutronclient.Client.delete_network('aaaa').AndReturn(None) def mock_delete_subnet(self): self.mock_router_for_vpc() neutronclient.Client.remove_interface_router( u'bbbb', {'subnet_id': 'cccc'}).AndReturn(None) neutronclient.Client.delete_subnet('cccc').AndReturn(None) def mock_create_route_table(self): self.rt_name = utils.PhysName('test_stack', 'the_route_table') neutronclient.Client.create_router({ 'router': {'name': self.rt_name}}).AndReturn({ 'router': { 'status': 'BUILD', 'name': self.rt_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'ffff' } }) neutronclient.Client.show_router('ffff').AndReturn({ 'router': { 'status': 'BUILD', 'name': self.rt_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'ffff' } }) neutronclient.Client.show_router('ffff').AndReturn({ 'router': { 'status': 'ACTIVE', 'name': self.rt_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'ffff' } }) self.mock_router_for_vpc() neutronclient.Client.add_gateway_router( 'ffff', {'network_id': 'zzzz'}).AndReturn(None) def mock_create_association(self): self.mock_show_subnet() self.mock_router_for_vpc() neutronclient.Client.remove_interface_router( 'bbbb', {'subnet_id': u'cccc'}).AndReturn(None) neutronclient.Client.add_interface_router( u'ffff', {'subnet_id': 'cccc'}).AndReturn(None) def mock_delete_association(self): self.mock_show_subnet() self.mock_router_for_vpc() neutronclient.Client.remove_interface_router( 'ffff', {'subnet_id': u'cccc'}).AndReturn(None) neutronclient.Client.add_interface_router( u'bbbb', {'subnet_id': 'cccc'}).AndReturn(None) def mock_delete_route_table(self): neutronclient.Client.delete_router('ffff').AndReturn(None) neutronclient.Client.remove_gateway_router('ffff').AndReturn(None) def assertResourceState(self, resource, ref_id): self.assertIsNone(resource.validate()) self.assertEqual((resource.CREATE, resource.COMPLETE), resource.state) self.assertEqual(ref_id, resource.FnGetRefId()) class VPCTest(VPCTestBase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_vpc: Type: AWS::EC2::VPC Properties: {CidrBlock: '10.0.0.0/16'} ''' def test_vpc(self): self.mock_keystone() self.mock_create_network() self.mock_delete_network() self.m.ReplayAll() stack = self.create_stack(self.test_template) vpc = stack['the_vpc'] self.assertResourceState(vpc, 'aaaa') self.assertRaises(resource.UpdateReplace, vpc.handle_update, {}, {}, {}) scheduler.TaskRunner(vpc.delete)() self.m.VerifyAll() class SubnetTest(VPCTestBase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_vpc: Type: AWS::EC2::VPC Properties: {CidrBlock: '10.0.0.0/16'} the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon ''' def test_subnet(self): self.mock_keystone() self.mock_create_network() self.mock_create_subnet() self.mock_delete_subnet() self.mock_delete_network() # mock delete subnet which is already deleted self.mock_router_for_vpc() neutronclient.Client.remove_interface_router( u'bbbb', {'subnet_id': 'cccc'}).AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_subnet('cccc').AndRaise( NeutronClientException(status_code=404)) self.m.ReplayAll() stack = self.create_stack(self.test_template) subnet = stack['the_subnet'] self.assertResourceState(subnet, 'cccc') self.assertRaises(resource.UpdateReplace, subnet.handle_update, {}, {}, {}) self.assertRaises( exception.InvalidTemplateAttribute, subnet.FnGetAtt, 'Foo') self.assertEqual('moon', subnet.FnGetAtt('AvailabilityZone')) scheduler.TaskRunner(subnet.delete)() subnet.state_set(subnet.CREATE, subnet.COMPLETE, 'to delete again') scheduler.TaskRunner(subnet.delete)() scheduler.TaskRunner(stack['the_vpc'].delete)() self.m.VerifyAll() class NetworkInterfaceTest(VPCTestBase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: AWS::EC2::SecurityGroup Properties: VpcId: {Ref: the_vpc} GroupDescription: SSH access SecurityGroupIngress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 0.0.0.0/0 the_vpc: Type: AWS::EC2::VPC Properties: {CidrBlock: '10.0.0.0/16'} the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon the_nic: Type: AWS::EC2::NetworkInterface Properties: PrivateIpAddress: 10.0.0.100 SubnetId: {Ref: the_subnet} GroupSet: - Ref: the_sg ''' test_template_no_groupset = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_vpc: Type: AWS::EC2::VPC Properties: {CidrBlock: '10.0.0.0/16'} the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon the_nic: Type: AWS::EC2::NetworkInterface Properties: PrivateIpAddress: 10.0.0.100 SubnetId: {Ref: the_subnet} ''' test_template_error = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: AWS::EC2::SecurityGroup Properties: VpcId: {Ref: the_vpc} GroupDescription: SSH access SecurityGroupIngress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 0.0.0.0/0 the_vpc: Type: AWS::EC2::VPC Properties: {CidrBlock: '10.0.0.0/16'} the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon the_nic: Type: AWS::EC2::NetworkInterface Properties: PrivateIpAddress: 10.0.0.100 SubnetId: {Ref: the_subnet} GroupSet: - Ref: INVALID-REF-IN-TEMPLATE ''' test_template_error_no_ref = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_vpc: Type: AWS::EC2::VPC Properties: {CidrBlock: '10.0.0.0/16'} the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon the_nic: Type: AWS::EC2::NetworkInterface Properties: PrivateIpAddress: 10.0.0.100 SubnetId: {Ref: the_subnet} GroupSet: - INVALID-NO-REF ''' def mock_create_network_interface( self, security_groups=['0389f747-7785-4757-b7bb-2ab07e4b09c3']): self.nic_name = utils.PhysName('test_stack', 'the_nic') port = {'network_id': 'aaaa', 'fixed_ips': [{ 'subnet_id': u'cccc', 'ip_address': u'10.0.0.100' }], 'name': self.nic_name, 'admin_state_up': True} if security_groups: port['security_groups'] = security_groups neutronclient.Client.create_port({'port': port}).AndReturn({ 'port': { 'admin_state_up': True, 'device_id': '', 'device_owner': '', 'fixed_ips': [ { 'ip_address': '10.0.0.100', 'subnet_id': 'cccc' } ], 'id': 'dddd', 'mac_address': 'fa:16:3e:25:32:5d', 'name': self.nic_name, 'network_id': 'aaaa', 'status': 'ACTIVE', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f' } }) def mock_show_network_interface(self): self.nic_name = utils.PhysName('test_stack', 'the_nic') neutronclient.Client.show_port('dddd').AndReturn({ 'port': { 'admin_state_up': True, 'device_id': '', 'device_owner': '', 'fixed_ips': [ { 'ip_address': '10.0.0.100', 'subnet_id': 'cccc' } ], 'id': 'dddd', 'mac_address': 'fa:16:3e:25:32:5d', 'name': self.nic_name, 'network_id': 'aaaa', 'security_groups': ['0389f747-7785-4757-b7bb-2ab07e4b09c3'], 'status': 'ACTIVE', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f' } }) def mock_delete_network_interface(self): neutronclient.Client.delete_port('dddd').AndReturn(None) def test_network_interface(self): self.mock_keystone() self.mock_create_security_group() self.mock_create_network() self.mock_create_subnet() self.mock_show_subnet() self.mock_create_network_interface() self.mock_show_network_interface() self.mock_delete_network_interface() self.mock_delete_subnet() self.mock_delete_network() self.mock_delete_security_group() self.m.ReplayAll() stack = self.create_stack(self.test_template) try: self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) rsrc = stack['the_nic'] self.assertResourceState(rsrc, 'dddd') self.assertEqual('10.0.0.100', rsrc.FnGetAtt('PrivateIpAddress')) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) finally: scheduler.TaskRunner(stack.delete)() self.m.VerifyAll() def test_network_interface_existing_groupset(self): self.m.StubOutWithMock(parser.Stack, 'resource_by_refid') self.mock_keystone() self.mock_create_security_group() self.mock_create_network() self.mock_create_subnet() self.mock_show_subnet() self.mock_create_network_interface() self.mock_delete_network_interface() self.mock_delete_subnet() self.mock_delete_network() self.mock_delete_security_group() self.m.ReplayAll() stack = self.create_stack(self.test_template) try: self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) rsrc = stack['the_nic'] self.assertResourceState(rsrc, 'dddd') self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) finally: stack.delete() self.m.VerifyAll() def test_network_interface_no_groupset(self): self.mock_keystone() self.mock_create_network() self.mock_create_subnet() self.mock_show_subnet() self.mock_create_network_interface(security_groups=None) self.mock_delete_network_interface() self.mock_delete_subnet() self.mock_delete_network() self.m.ReplayAll() stack = self.create_stack(self.test_template_no_groupset) stack.delete() self.m.VerifyAll() def test_network_interface_error(self): real_exception = self.assertRaises( exception.InvalidTemplateReference, self.create_stack, self.test_template_error) expected_exception = exception.InvalidTemplateReference( resource='INVALID-REF-IN-TEMPLATE', key='the_nic.Properties.GroupSet[0]') self.assertEqual(str(expected_exception), str(real_exception)) class InternetGatewayTest(VPCTestBase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_gateway: Type: AWS::EC2::InternetGateway the_vpc: Type: AWS::EC2::VPC Properties: CidrBlock: '10.0.0.0/16' the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon the_attachment: Type: AWS::EC2::VPCGatewayAttachment Properties: VpcId: {Ref: the_vpc} InternetGatewayId: {Ref: the_gateway} the_route_table: Type: AWS::EC2::RouteTable Properties: VpcId: {Ref: the_vpc} the_association: Type: AWS::EC2::SubnetRouteTableAssociation Properties: RouteTableId: {Ref: the_route_table} SubnetId: {Ref: the_subnet} ''' def mock_create_internet_gateway(self): neutronclient.Client.list_networks( **{'router:external': True}).AndReturn({'networks': [{ 'status': 'ACTIVE', 'subnets': [], 'name': 'nova', 'router:external': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'admin_state_up': True, 'shared': True, 'id': '0389f747-7785-4757-b7bb-2ab07e4b09c3' }]}) def mock_create_gateway_attachment(self): neutronclient.Client.add_gateway_router( 'ffff', {'network_id': '0389f747-7785-4757-b7bb-2ab07e4b09c3'} ).AndReturn(None) def mock_delete_gateway_attachment(self): neutronclient.Client.remove_gateway_router('ffff').AndReturn(None) def test_internet_gateway(self): self.mock_keystone() self.mock_create_internet_gateway() self.mock_create_network() self.mock_create_subnet() self.mock_create_route_table() self.mock_create_association() self.mock_create_gateway_attachment() self.mock_delete_gateway_attachment() self.mock_delete_association() self.mock_delete_route_table() self.mock_delete_subnet() self.mock_delete_network() self.m.ReplayAll() stack = self.create_stack(self.test_template) gateway = stack['the_gateway'] self.assertResourceState(gateway, gateway.physical_resource_name()) self.assertRaises(resource.UpdateReplace, gateway.handle_update, {}, {}, {}) attachment = stack['the_attachment'] self.assertResourceState(attachment, 'the_attachment') self.assertRaises(resource.UpdateReplace, attachment.handle_update, {}, {}, {}) route_table = stack['the_route_table'] self.assertEqual(list(attachment._vpc_route_tables()), [route_table]) stack.delete() self.m.VerifyAll() class RouteTableTest(VPCTestBase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_vpc: Type: AWS::EC2::VPC Properties: CidrBlock: '10.0.0.0/16' the_subnet: Type: AWS::EC2::Subnet Properties: CidrBlock: 10.0.0.0/24 VpcId: {Ref: the_vpc} AvailabilityZone: moon the_route_table: Type: AWS::EC2::RouteTable Properties: VpcId: {Ref: the_vpc} the_association: Type: AWS::EC2::SubnetRouteTableAssociation Properties: RouteTableId: {Ref: the_route_table} SubnetId: {Ref: the_subnet} ''' def test_route_table(self): self.mock_keystone() self.mock_create_network() self.mock_create_subnet() self.mock_create_route_table() self.mock_create_association() self.mock_delete_association() self.mock_delete_route_table() self.mock_delete_subnet() self.mock_delete_network() self.m.ReplayAll() stack = self.create_stack(self.test_template) route_table = stack['the_route_table'] self.assertResourceState(route_table, 'ffff') self.assertRaises( resource.UpdateReplace, route_table.handle_update, {}, {}, {}) association = stack['the_association'] self.assertResourceState(association, 'the_association') self.assertRaises( resource.UpdateReplace, association.handle_update, {}, {}, {}) scheduler.TaskRunner(association.delete)() scheduler.TaskRunner(route_table.delete)() stack.delete() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_neutron_network_gateway.py0000664000567000056700000004136312540642614024520 0ustar jenkinsjenkins00000000000000 # Copyright 2013 NTT Corp. # 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. from mox import IgnoreArg from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.resources.neutron import network_gateway from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils neutronclient = try_import('neutronclient.v2_0.client') neutronV20 = try_import('neutronclient.neutron.v2_0') qe = try_import('neutronclient.common.exceptions') gw_template = ''' { 'AWSTemplateFormatVersion': '2010-09-09', 'Description': 'Template to test Network Gateway resource', 'Parameters': {}, 'Resources': { 'NetworkGateway': { 'Type': 'OS::Neutron::NetworkGateway', 'Properties': { 'name': 'NetworkGateway', 'devices': [{ 'id': 'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': 'breth1'}], 'connections': [{ 'network_id': '6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_type': 'vlan', 'segmentation_id': 10}] } } } } ''' sng = { 'network_gateway': { 'id': 'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'name': 'NetworkGateway', 'default': False, 'tenant_id': '96ba52dc-c5c5-44c6-9a9d-d3ba1a03f77f', 'devices': [{ 'id': 'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': 'breth1'}], 'ports': [{ 'segmentation_type': 'vlan', 'port_id': '32acc49c-899e-44ea-8177-6f4157e12eb4', 'segmentation_id': 10}] } } @skipIf(neutronclient is None, 'neutronclient unavailable') class NeutronNetworkGatewayTest(HeatTestCase): @skipIf(neutronV20 is None, 'Missing Neutron v2_0') def setUp(self): super(NeutronNetworkGatewayTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_network_gateway') self.m.StubOutWithMock(neutronclient.Client, 'show_network_gateway') self.m.StubOutWithMock(neutronclient.Client, 'delete_network_gateway') self.m.StubOutWithMock(neutronclient.Client, 'connect_network_gateway') self.m.StubOutWithMock(neutronclient.Client, 'update_network_gateway') self.m.StubOutWithMock(neutronclient.Client, 'disconnect_network_gateway') self.m.StubOutWithMock(neutronclient.Client, 'list_networks') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def prepare_create_network_gateway(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_network_gateway({ 'network_gateway': { 'name': u'NetworkGateway', 'devices': [{'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth1'}] } } ).AndReturn({ 'network_gateway': { 'id': 'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'name': 'NetworkGateway', 'default': False, 'tenant_id': '96ba52dc-c5c5-44c6-9a9d-d3ba1a03f77f', 'devices': [{ 'id': 'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': 'breth1'}] } } ) neutronclient.Client.connect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndReturn({ 'connection_info': { 'network_gateway_id': u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'port_id': u'32acc49c-899e-44ea-8177-6f4157e12eb4' } }) t = template_format.parse(gw_template) stack = utils.parse_stack(t) rsrc = network_gateway.NetworkGateway( 'test_network_gateway', t['Resources']['NetworkGateway'], stack) return rsrc def test_network_gateway_create(self): rsrc = self.prepare_create_network_gateway() neutronclient.Client.disconnect_network_gateway( 'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndReturn(None) neutronclient.Client.disconnect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndReturn(qe.NeutronClientException(status_code=404)) neutronclient.Client.delete_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37' ).AndReturn(None) neutronclient.Client.show_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37' ).AndReturn(sng) neutronclient.Client.show_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37' ).AndRaise(qe.NeutronClientException(status_code=404)) neutronclient.Client.delete_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37' ).AndRaise(qe.NeutronClientException(status_code=404)) self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) ref_id = rsrc.FnGetRefId() self.assertEqual(u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', ref_id) self.assertRaises( exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_network_gateway_update(self): rsrc = self.prepare_create_network_gateway() neutronclient.Client.update_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_gateway': { 'name': u'NetworkGatewayUpdate' } } ).AndReturn(None) neutronclient.Client.disconnect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndReturn(None) neutronclient.Client.connect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 0, 'segmentation_type': u'flat' } ).AndReturn({ 'connection_info': { 'network_gateway_id': u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'port_id': u'aa800972-f6be-4c65-8453-9ab31834bf80' } }) neutronclient.Client.disconnect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndRaise(qe.NeutronClientException(status_code=404)) neutronclient.Client.connect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 0, 'segmentation_type': u'flat' } ).AndReturn({ 'connection_info': { 'network_gateway_id': u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'port_id': u'aa800972-f6be-4c65-8453-9ab31834bf80' } }) neutronclient.Client.disconnect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndReturn(None) neutronclient.Client.delete_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37' ).AndReturn(None) neutronclient.Client.create_network_gateway({ 'network_gateway': { 'name': u'NetworkGateway', 'devices': [{'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth2'}] } } ).AndReturn({ 'network_gateway': { 'id': 'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'name': 'NetworkGateway', 'default': False, 'tenant_id': '96ba52dc-c5c5-44c6-9a9d-d3ba1a03f77f', 'devices': [{ 'id': 'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': 'breth2'}] } } ) neutronclient.Client.connect_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', { 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_id': 10, 'segmentation_type': u'vlan' } ).AndReturn({ 'connection_info': { 'network_gateway_id': u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'port_id': u'aa800972-f6be-4c65-8453-9ab31834bf80' } }) self.m.ReplayAll() rsrc.validate() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) # update name snippet_for_update = { 'Type': u'OS::Neutron::NetworkGatewayUpdate', 'Properties': { 'name': u'NetworkGatewayUpdate', 'devices': [{ 'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth1'}], 'connections': [{ 'network_id': '6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_type': 'vlan', 'segmentation_id': 10}] } } prop_diff = {'name': u'NetworkGatewayUpdate'} self.assertIsNone(rsrc.handle_update(snippet_for_update, IgnoreArg(), prop_diff)) # update connections snippet_for_update = { 'Type': u'OS::Neutron::NetworkGateway', 'Properties': { 'name': u'NetworkGateway', 'devices': [{ 'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth1'}], 'connections': [{ 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_type': u'flat', 'segmentation_id': 0}] } } prop_diff = { 'connections': [{ 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_type': u'flat', 'segmentation_id': 0}] } self.assertIsNone(rsrc.handle_update(snippet_for_update, IgnoreArg(), prop_diff)) # update connections once more self.assertIsNone(rsrc.handle_update(snippet_for_update, IgnoreArg(), prop_diff)) # update devices snippet_for_update = { 'Type': u'OS::Neutron::NetworkGateway', 'Properties': { 'name': u'NetworkGateway', 'devices': [{ 'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth2'}], 'connections': [{ 'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35', 'segmentation_type': u'vlan', 'segmentation_id': 10}] } } prop_diff = { 'devices': [{ 'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth2'}] } self.assertIsNone(rsrc.handle_update(snippet_for_update, IgnoreArg(), prop_diff)) self.m.VerifyAll() def test_network_gatway_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_network_gateway({ 'network_gateway': { 'name': u'NetworkGateway', 'devices': [{ 'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb', 'interface_name': u'breth1'}] } } ).AndRaise(network_gateway.NeutronClientException) self.m.ReplayAll() t = template_format.parse(gw_template) stack = utils.parse_stack(t) rsrc = network_gateway.NetworkGateway( 'network_gateway', t['Resources']['NetworkGateway'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.assertIsNone(scheduler.TaskRunner(rsrc.delete)()) self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_gateway_validate_failed_with_vlan(self): t = template_format.parse(gw_template) del t['Resources']['NetworkGateway']['Properties'][ 'connections'][0]['segmentation_id'] stack = utils.parse_stack(t) rsrc = network_gateway.NetworkGateway( 'test_network_gateway', t['Resources']['NetworkGateway'], stack) self.m.ReplayAll() error = self.assertRaises(exception.StackValidationFailed, scheduler.TaskRunner(rsrc.validate)) self.assertEqual( 'segmentation_id must be specified for using vlan', str(error)) self.m.VerifyAll() def test_gateway_validate_failed_with_flat(self): t = template_format.parse(gw_template) t['Resources']['NetworkGateway']['Properties'][ 'connections'][0]['segmentation_type'] = 'flat' stack = utils.parse_stack(t) rsrc = network_gateway.NetworkGateway( 'test_network_gateway', t['Resources']['NetworkGateway'], stack) self.m.ReplayAll() error = self.assertRaises(exception.StackValidationFailed, scheduler.TaskRunner(rsrc.validate)) self.assertEqual( 'segmentation_id cannot be specified except 0 for using flat', str(error)) self.m.VerifyAll() def test_network_gateway_attribute(self): neutronclient.Client.show_network_gateway( u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37' ).MultipleTimes().AndReturn(sng) rsrc = self.prepare_create_network_gateway() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual(u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', rsrc.FnGetRefId()) self.assertEqual(False, rsrc.FnGetAtt('default')) error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'hoge') self.assertEqual( 'The Referenced Attribute (test_network_gateway hoge) is ' 'incorrect.', str(error)) self.m.VerifyAll() heat-2014.1.5/heat/tests/generic_resource.py0000664000567000056700000001045512540642614022016 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. from heat.engine import resource from heat.engine import signal_responder from heat.engine import stack_user from heat.openstack.common.gettextutils import _ from heat.openstack.common import log as logging logger = logging.getLogger(__name__) class GenericResource(resource.Resource): ''' Dummy resource for use in tests ''' properties_schema = {} attributes_schema = {'foo': 'A generic attribute', 'Foo': 'Another generic attribute'} def handle_create(self): logger.warning(_('Creating generic resource (Type "%s")') % self.type()) def handle_update(self, json_snippet, tmpl_diff, prop_diff): logger.warning(_('Updating generic resource (Type "%s")') % self.type()) def handle_delete(self): logger.warning(_('Deleting generic resource (Type "%s")') % self.type()) def _resolve_attribute(self, name): return self.name def handle_suspend(self): logger.warning(_('Suspending generic resource (Type "%s")') % self.type()) def handle_resume(self): logger.warning(_('Resuming generic resource (Type "%s")') % self.type()) class ResWithComplexPropsAndAttrs(GenericResource): properties_schema = {'a_string': {'Type': 'String'}, 'a_list': {'Type': 'List'}, 'a_map': {'Type': 'Map'}} attributes_schema = {'list': 'A list', 'map': 'A map', 'string': 'A string'} def _resolve_attribute(self, name): try: return self.properties["a_%s" % name] except KeyError: return None class ResourceWithProps(GenericResource): properties_schema = {'Foo': {'Type': 'String'}} class ResourceWithComplexAttributes(GenericResource): attributes_schema = {'list': 'A list', 'flat_dict': 'A flat dictionary', 'nested_dict': 'A nested dictionary', 'none': 'A None' } list = ['foo', 'bar'] flat_dict = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'} nested_dict = {'list': [1, 2, 3], 'string': 'abc', 'dict': {'a': 1, 'b': 2, 'c': 3}} def _resolve_attribute(self, name): if name == 'list': return self.list if name == 'flat_dict': return self.flat_dict if name == 'nested_dict': return self.nested_dict if name == 'none': return None class ResourceWithRequiredProps(GenericResource): properties_schema = {'Foo': {'Type': 'String', 'Required': True}} class SignalResource(signal_responder.SignalResponder): properties_schema = {} attributes_schema = {'AlarmUrl': 'Get a signed webhook'} def handle_create(self): super(SignalResource, self).handle_create() self.resource_id_set(self._get_user_id()) def handle_signal(self, details=None): if self.action in (self.SUSPEND, self.DELETE): msg = _('Cannot signal resource during %s') % self.action raise Exception(msg) logger.warning(_('Signaled resource (Type "%(type)s") %(details)s') % {'type': self.type(), 'details': details}) def _resolve_attribute(self, name): if name == 'AlarmUrl' and self.resource_id is not None: return unicode(self._get_signed_url()) class StackUserResource(stack_user.StackUser): properties_schema = {} attributes_schema = {} def handle_create(self): super(StackUserResource, self).handle_create() self.resource_id_set(self._get_user_id()) heat-2014.1.5/heat/tests/test_parameters.py0000664000567000056700000004170512540642614021677 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. import json import testtools from heat.common import exception from heat.common import identifier from heat.engine import constraints as constr from heat.engine import parameters from heat.engine import template class ParameterTest(testtools.TestCase): def new_parameter(self, name, schema, value=None, validate_value=True): tmpl = template.Template({'Parameters': {name: schema}}) schema = tmpl.param_schemata()[name] param = parameters.Parameter(name, schema, value) param.validate(validate_value) return param def test_new_string(self): p = self.new_parameter('p', {'Type': 'String'}, validate_value=False) self.assertIsInstance(p, parameters.StringParam) def test_new_number(self): p = self.new_parameter('p', {'Type': 'Number'}, validate_value=False) self.assertIsInstance(p, parameters.NumberParam) def test_new_list(self): p = self.new_parameter('p', {'Type': 'CommaDelimitedList'}, validate_value=False) self.assertIsInstance(p, parameters.CommaDelimitedListParam) def test_new_json(self): p = self.new_parameter('p', {'Type': 'Json'}, validate_value=False) self.assertIsInstance(p, parameters.JsonParam) def test_new_bad_type(self): self.assertRaises(constr.InvalidSchemaError, self.new_parameter, 'p', {'Type': 'List'}, validate_value=False) def test_default_no_override(self): p = self.new_parameter('defaulted', {'Type': 'String', 'Default': 'blarg'}) self.assertTrue(p.has_default()) self.assertEqual('blarg', p.default()) self.assertEqual('blarg', p.value()) def test_default_override(self): p = self.new_parameter('defaulted', {'Type': 'String', 'Default': 'blarg'}, 'wibble') self.assertTrue(p.has_default()) self.assertEqual('blarg', p.default()) self.assertEqual('wibble', p.value()) def test_default_invalid(self): schema = {'Type': 'String', 'AllowedValues': ['foo'], 'ConstraintDescription': 'wibble', 'Default': 'bar'} err = self.assertRaises(constr.InvalidSchemaError, self.new_parameter, 'p', schema, 'foo') self.assertIn('wibble', str(err)) def test_no_echo_true(self): p = self.new_parameter('anechoic', {'Type': 'String', 'NoEcho': 'true'}, 'wibble') self.assertTrue(p.hidden()) self.assertNotEqual(str(p), 'wibble') def test_no_echo_true_caps(self): p = self.new_parameter('anechoic', {'Type': 'String', 'NoEcho': 'TrUe'}, 'wibble') self.assertTrue(p.hidden()) self.assertNotEqual(str(p), 'wibble') def test_no_echo_false(self): p = self.new_parameter('echoic', {'Type': 'String', 'NoEcho': 'false'}, 'wibble') self.assertFalse(p.hidden()) self.assertEqual('wibble', str(p)) def test_description(self): description = 'Description of the parameter' p = self.new_parameter('p', {'Type': 'String', 'Description': description}, validate_value=False) self.assertEqual(description, p.description()) def test_no_description(self): p = self.new_parameter('p', {'Type': 'String'}, validate_value=False) self.assertEqual('', p.description()) def test_string_len_good(self): schema = {'Type': 'String', 'MinLength': '3', 'MaxLength': '3'} p = self.new_parameter('p', schema, 'foo') self.assertEqual('foo', p.value()) def test_string_underflow(self): schema = {'Type': 'String', 'ConstraintDescription': 'wibble', 'MinLength': '4'} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, 'foo') self.assertIn('wibble', str(err)) def test_string_overflow(self): schema = {'Type': 'String', 'ConstraintDescription': 'wibble', 'MaxLength': '2'} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, 'foo') self.assertIn('wibble', str(err)) def test_string_pattern_good(self): schema = {'Type': 'String', 'AllowedPattern': '[a-z]*'} p = self.new_parameter('p', schema, 'foo') self.assertEqual('foo', p.value()) def test_string_pattern_bad_prefix(self): schema = {'Type': 'String', 'ConstraintDescription': 'wibble', 'AllowedPattern': '[a-z]*'} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, '1foo') self.assertIn('wibble', str(err)) def test_string_pattern_bad_suffix(self): schema = {'Type': 'String', 'ConstraintDescription': 'wibble', 'AllowedPattern': '[a-z]*'} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, 'foo1') self.assertIn('wibble', str(err)) def test_string_value_list_good(self): schema = {'Type': 'String', 'AllowedValues': ['foo', 'bar', 'baz']} p = self.new_parameter('p', schema, 'bar') self.assertEqual('bar', p.value()) def test_string_value_unicode(self): schema = {'Type': 'String'} p = self.new_parameter('p', schema, u'test\u2665') self.assertEqual(u'test\u2665', p.value()) def test_string_value_list_bad(self): schema = {'Type': 'String', 'ConstraintDescription': 'wibble', 'AllowedValues': ['foo', 'bar', 'baz']} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, 'blarg') self.assertIn('wibble', str(err)) def test_number_int_good(self): schema = {'Type': 'Number', 'MinValue': '3', 'MaxValue': '3'} p = self.new_parameter('p', schema, '3') self.assertEqual(3, p.value()) def test_number_float_good(self): schema = {'Type': 'Number', 'MinValue': '3.0', 'MaxValue': '4.0'} p = self.new_parameter('p', schema, '3.5') self.assertEqual(3.5, p.value()) def test_number_low(self): schema = {'Type': 'Number', 'ConstraintDescription': 'wibble', 'MinValue': '4'} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, '3') self.assertIn('wibble', str(err)) def test_number_high(self): schema = {'Type': 'Number', 'ConstraintDescription': 'wibble', 'MaxValue': '2'} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, '3') self.assertIn('wibble', str(err)) def test_number_value_list_good(self): schema = {'Type': 'Number', 'AllowedValues': ['1', '3', '5']} p = self.new_parameter('p', schema, '5') self.assertEqual(5, p.value()) def test_number_value_list_bad(self): schema = {'Type': 'Number', 'ConstraintDescription': 'wibble', 'AllowedValues': ['1', '3', '5']} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, '2') self.assertIn('wibble', str(err)) def test_list_value_list_good(self): schema = {'Type': 'CommaDelimitedList', 'AllowedValues': ['foo', 'bar', 'baz']} p = self.new_parameter('p', schema, 'baz,foo,bar') self.assertEqual('baz,foo,bar'.split(','), p.value()) schema['Default'] = [] p = self.new_parameter('p', schema) self.assertEqual([], p.value()) schema['Default'] = 'baz,foo,bar' p = self.new_parameter('p', schema) self.assertEqual('baz,foo,bar'.split(','), p.value()) def test_list_value_list_bad(self): schema = {'Type': 'CommaDelimitedList', 'ConstraintDescription': 'wibble', 'AllowedValues': ['foo', 'bar', 'baz']} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, 'foo,baz,blarg') self.assertIn('wibble', str(err)) def test_map_value(self): '''Happy path for value thats already a map.''' schema = {'Type': 'Json'} val = {"foo": "bar", "items": [1, 2, 3]} p = self.new_parameter('p', schema, val) self.assertEqual(val, p.value()) self.assertEqual(val, p.parsed) def test_map_value_bad(self): '''Map value is not JSON parsable.''' schema = {'Type': 'Json', 'ConstraintDescription': 'wibble'} val = {"foo": "bar", "not_json": len} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, val) self.assertIn('Value must be valid JSON', str(err)) def test_map_value_parse(self): '''Happy path for value that's a string.''' schema = {'Type': 'Json'} val = {"foo": "bar", "items": [1, 2, 3]} val_s = json.dumps(val) p = self.new_parameter('p', schema, val_s) self.assertEqual(val, p.value()) self.assertEqual(val, p.parsed) def test_map_value_bad_parse(self): '''Test value error for unparsable string value.''' schema = {'Type': 'Json', 'ConstraintDescription': 'wibble'} val = "I am not a map" err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, val) self.assertIn('Value must be valid JSON', str(err)) def test_map_underrun(self): '''Test map length under MIN_LEN.''' schema = {'Type': 'Json', 'MinLength': 3} val = {"foo": "bar", "items": [1, 2, 3]} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, val) self.assertIn('out of range', str(err)) def test_map_overrun(self): '''Test map length over MAX_LEN.''' schema = {'Type': 'Json', 'MaxLength': 1} val = {"foo": "bar", "items": [1, 2, 3]} err = self.assertRaises(ValueError, self.new_parameter, 'p', schema, val) self.assertIn('out of range', str(err)) def test_missing_param(self): '''Test missing user parameter.''' self.assertRaises(exception.UserParameterMissing, self.new_parameter, 'p', {'Type': 'String'}) params_schema = json.loads('''{ "Parameters" : { "User" : { "Type": "String" }, "Defaulted" : { "Type": "String", "Default": "foobar" } } }''') class ParametersTest(testtools.TestCase): def new_parameters(self, stack_name, tmpl, user_params={}, stack_id=None, validate_value=True): tmpl = template.Template(tmpl) params = tmpl.parameters( identifier.HeatIdentifier('', stack_name, stack_id), user_params) params.validate(validate_value) return params def test_pseudo_params(self): stack_name = 'test_stack' params = self.new_parameters(stack_name, {"Parameters": {}}) self.assertEqual('test_stack', params['AWS::StackName']) self.assertEqual( 'arn:openstack:heat:::stacks/{0}/{1}'.format(stack_name, 'None'), params['AWS::StackId']) self.assertIn('AWS::Region', params) def test_pseudo_param_stackid(self): stack_name = 'test_stack' params = self.new_parameters(stack_name, {'Parameters': {}}, stack_id='abc123') self.assertEqual( 'arn:openstack:heat:::stacks/{0}/{1}'.format(stack_name, 'abc123'), params['AWS::StackId']) stack_identifier = identifier.HeatIdentifier('', '', 'def456') params.set_stack_id(stack_identifier) self.assertEqual(stack_identifier.arn(), params['AWS::StackId']) def test_schema_invariance(self): params1 = self.new_parameters('test', params_schema, {'User': 'foo', 'Defaulted': 'wibble'}) self.assertEqual('wibble', params1['Defaulted']) params2 = self.new_parameters('test', params_schema, {'User': 'foo'}) self.assertEqual('foobar', params2['Defaulted']) def test_to_dict(self): template = {'Parameters': {'Foo': {'Type': 'String'}, 'Bar': {'Type': 'Number', 'Default': '42'}}} params = self.new_parameters('test_params', template, {'Foo': 'foo'}) as_dict = dict(params) self.assertEqual('foo', as_dict['Foo']) self.assertEqual(42, as_dict['Bar']) self.assertEqual('test_params', as_dict['AWS::StackName']) self.assertIn('AWS::Region', as_dict) def test_map(self): template = {'Parameters': {'Foo': {'Type': 'String'}, 'Bar': {'Type': 'Number', 'Default': '42'}}} params = self.new_parameters('test_params', template, {'Foo': 'foo'}) expected = {'Foo': False, 'Bar': True, 'AWS::Region': True, 'AWS::StackId': True, 'AWS::StackName': True} self.assertEqual(expected, params.map(lambda p: p.has_default())) def test_map_str(self): template = {'Parameters': {'Foo': {'Type': 'String'}, 'Bar': {'Type': 'Number'}, 'Uni': {'Type': 'String'}}} stack_name = 'test_params' params = self.new_parameters(stack_name, template, {'Foo': 'foo', 'Bar': '42', 'Uni': u'test\u2665'}) expected = {'Foo': 'foo', 'Bar': '42', 'Uni': 'test\xe2\x99\xa5', 'AWS::Region': 'ap-southeast-1', 'AWS::StackId': 'arn:openstack:heat:::stacks/{0}/{1}'.format( stack_name, 'None'), 'AWS::StackName': 'test_params'} self.assertEqual(expected, params.map(str)) def test_unknown_params(self): user_params = {'Foo': 'wibble'} self.assertRaises(exception.UnknownUserParameter, self.new_parameters, 'test', params_schema, user_params) def test_missing_params(self): user_params = {} self.assertRaises(exception.UserParameterMissing, self.new_parameters, 'test', params_schema, user_params) def test_missing_attribute_params(self): params = {'Parameters': {'Foo': {'Type': 'String'}, 'NoAttr': 'No attribute.', 'Bar': {'Type': 'Number', 'Default': '1'}}} self.assertRaises(constr.InvalidSchemaError, self.new_parameters, 'test', params) class ParameterSchemaTest(testtools.TestCase): def test_validate_schema_wrong_key(self): error = self.assertRaises(constr.InvalidSchemaError, parameters.Schema.from_dict, {"foo": "bar"}) self.assertEqual("Invalid key 'foo' for parameter", str(error)) def test_validate_schema_no_type(self): error = self.assertRaises(constr.InvalidSchemaError, parameters.Schema.from_dict, {"Description": "Hi!"}) self.assertEqual("Missing parameter type", str(error)) heat-2014.1.5/heat/tests/test_structured_config.py0000664000567000056700000001436412540642614023266 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. import mock from heat.engine import parser from heat.engine.resources.software_config import structured_config as sc from heat.engine import template from heat.tests.common import HeatTestCase from heat.tests import utils class StructuredConfigTestJSON(HeatTestCase): template = { 'Resources': { 'config_mysql': { 'Type': 'OS::Heat::StructuredConfig', 'Properties': {'config': {'foo': 'bar'}} } } } stored_config = {'foo': 'bar'} def setUp(self): super(StructuredConfigTestJSON, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() self.properties = { 'config': {'foo': 'bar'} } self.stack = parser.Stack( self.ctx, 'software_config_test_stack', template.Template(self.template)) self.config = self.stack['config_mysql'] heat = mock.MagicMock() self.config.heat = heat self.software_configs = heat.return_value.software_configs def test_resource_mapping(self): mapping = sc.resource_mapping() self.assertEqual(2, len(mapping)) self.assertEqual(sc.StructuredConfig, mapping['OS::Heat::StructuredConfig']) self.assertEqual(sc.StructuredDeployment, mapping['OS::Heat::StructuredDeployment']) self.assertIsInstance(self.config, sc.StructuredConfig) def test_handle_create(self): stc = mock.MagicMock() config_id = 'c8a19429-7fde-47ea-a42f-40045488226c' stc.id = config_id self.software_configs.create.return_value = stc self.config.handle_create() self.assertEqual(config_id, self.config.resource_id) kwargs = self.software_configs.create.call_args[1] self.assertEqual(self.stored_config, kwargs['config']) class StructuredDeploymentDerivedTest(HeatTestCase): template = { 'Resources': { 'deploy_mysql': { 'Type': 'OS::Heat::StructuredDeployment' } } } def setUp(self): super(StructuredDeploymentDerivedTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() props = { 'input_values': {'bar': 'baz'}, } self.template['Resources']['deploy_mysql']['Properties'] = props self.stack = parser.Stack( self.ctx, 'software_deploly_test_stack', template.Template(self.template)) self.deployment = self.stack['deploy_mysql'] heat = mock.MagicMock() self.deployments = heat.return_value.software_deployments def test_build_derived_config(self): source = { 'config': {"foo": {"get_input": "bar"}} } inputs = [{'name': 'bar', 'value': 'baz'}] result = self.deployment._build_derived_config( 'CREATE', source, inputs, {}) self.assertEqual({"foo": "baz"}, result) class StructuredDeploymentParseTest(HeatTestCase): scenarios = [ ( 'no_functions', dict(input_key='get_input', inputs={}, config={'foo': 'bar'}, result={'foo': 'bar'}), ), ( 'none_inputs', dict(input_key='get_input', inputs=None, config={'foo': 'bar'}, result={'foo': 'bar'}), ), ( 'none_config', dict(input_key='get_input', inputs=None, config=None, result=None), ), ( 'empty_config', dict(input_key='get_input', inputs=None, config='', result=''), ), ( 'simple', dict(input_key='get_input', inputs={'bar': 'baa'}, config={'foo': {'get_input': 'bar'}}, result={'foo': 'baa'}), ), ( 'multi_key', dict(input_key='get_input', inputs={'bar': 'baa'}, config={'foo': {'get_input': 'bar', 'other': 'thing'}}, result={'foo': {'get_input': 'bar', 'other': 'thing'}}), ), ( 'list_arg', dict(input_key='get_input', inputs={'bar': 'baa'}, config={'foo': {'get_input': ['bar', 'baz']}}, result={'foo': {'get_input': ['bar', 'baz']}}), ), ( 'missing_input', dict(input_key='get_input', inputs={'bar': 'baa'}, config={'foo': {'get_input': 'barr'}}, result={'foo': None}), ), ( 'deep', dict(input_key='get_input', inputs={'bar': 'baa'}, config={'foo': {'foo': {'get_input': 'bar'}}}, result={'foo': {'foo': 'baa'}}), ), ( 'shallow', dict(input_key='get_input', inputs={'bar': 'baa'}, config={'get_input': 'bar'}, result='baa'), ), ( 'list', dict(input_key='get_input', inputs={'bar': 'baa', 'bar2': 'baz', 'bar3': 'bink'}, config={'foo': [ {'get_input': 'bar'}, {'get_input': 'bar2'}, {'get_input': 'bar3'}]}, result={'foo': ['baa', 'baz', 'bink']}), ) ] def test_parse(self): parse = sc.StructuredDeployment.parse self.assertEqual( self.result, parse(self.inputs, self.input_key, self.config)) heat-2014.1.5/heat/tests/test_plugin_manager.py0000664000567000056700000000626712540642614022530 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # 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. import sys import types from heat.tests.common import HeatTestCase from heat.engine import plugin_manager def legacy_test_mapping(): return {'foo': 'bar', 'baz': 'quux'} def current_test_mapping(): return {'blarg': 'wibble', 'bar': 'baz'} def args_test_mapping(*args): return dict(enumerate(args)) def kwargs_test_mapping(**kwargs): return kwargs def error_test_mapping(): raise MappingTestError class MappingTestError(Exception): pass class TestPluginManager(HeatTestCase): @staticmethod def module(): return sys.modules[__name__] def test_load_single_mapping(self): pm = plugin_manager.PluginMapping('current_test') self.assertEqual(current_test_mapping(), pm.load_from_module(self.module())) def test_load_first_alternative_mapping(self): pm = plugin_manager.PluginMapping(['current_test', 'legacy_test']) self.assertEqual(current_test_mapping(), pm.load_from_module(self.module())) def test_load_second_alternative_mapping(self): pm = plugin_manager.PluginMapping(['nonexist', 'current_test']) self.assertEqual(current_test_mapping(), pm.load_from_module(self.module())) def test_load_mapping_args(self): pm = plugin_manager.PluginMapping('args_test', 'baz', 'quux') expected = {0: 'baz', 1: 'quux'} self.assertEqual(expected, pm.load_from_module(self.module())) def test_load_mapping_kwargs(self): pm = plugin_manager.PluginMapping('kwargs_test', baz='quux') self.assertEqual({'baz': 'quux'}, pm.load_from_module(self.module())) def test_load_mapping_non_existent(self): pm = plugin_manager.PluginMapping('nonexist') self.assertEqual({}, pm.load_from_module(self.module())) def test_load_mapping_error(self): pm = plugin_manager.PluginMapping('error_test') self.assertRaises(MappingTestError, pm.load_from_module, self.module()) def test_modules(self): mgr = plugin_manager.PluginManager('heat.tests') for module in mgr.modules: self.assertEqual(types.ModuleType, type(module)) self.assertTrue(module.__name__.startswith('heat.tests') or module.__name__.startswith('heat.engine.plugins')) def test_load_all(self): mgr = plugin_manager.PluginManager('heat.tests') pm = plugin_manager.PluginMapping('current_test') all_items = pm.load_all(mgr) for item in current_test_mapping().iteritems(): self.assertIn(item, all_items) heat-2014.1.5/heat/tests/test_ssl_middleware.py0000664000567000056700000000350412540642614022525 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. import webob from heat.api.middleware import ssl from oslo.config import cfg from heat.tests.common import HeatTestCase class SSLMiddlewareTest(HeatTestCase): scenarios = [('with_forwarded_proto_default_header', dict(forwarded_protocol='https', secure_proxy_ssl_header=None, headers={'X-Forwarded-Proto': 'https'})), ('with_forwarded_proto_non_default_header', dict(forwarded_protocol='http', secure_proxy_ssl_header='X-My-Forwarded-Proto', headers={})), ('without_forwarded_proto', dict(forwarded_protocol='http', secure_proxy_ssl_header=None, headers={}))] def test_ssl_middleware(self): if self.secure_proxy_ssl_header: cfg.CONF.set_override('secure_proxy_ssl_header', self.secure_proxy_ssl_header) middleware = ssl.SSLMiddleware(None) request = webob.Request.blank('/stacks', headers=self.headers) self.assertIsNone(middleware.process_request(request)) self.assertEqual(self.forwarded_protocol, request.environ['wsgi.url_scheme']) heat-2014.1.5/heat/tests/test_autoscaling.py0000664000567000056700000017521012540642614022044 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. import copy import datetime import mock import mox from oslo.config import cfg from testtools import skipIf from heat.common import exception from heat.common import short_id from heat.common import template_format from heat.engine.notification import autoscaling as notification from heat.engine import parser from heat.engine import resource from heat.engine.resource import Metadata from heat.engine.resources import autoscaling as asc from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import loadbalancer from heat.engine.resources.neutron import loadbalancer as neutron_lb from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.openstack.common import timeutils from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils neutronclient = try_import('neutronclient.v2_0.client') as_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "AutoScaling Test", "Parameters" : { "ImageId": {"Type": "String"}, "KeyName": {"Type": "String"} }, "Resources" : { "WebServerGroup" : { "Type" : "AWS::AutoScaling::AutoScalingGroup", "Properties" : { "AvailabilityZones" : ["nova"], "LaunchConfigurationName" : { "Ref" : "LaunchConfig" }, "MinSize" : "1", "MaxSize" : "5", "LoadBalancerNames" : [ { "Ref" : "ElasticLoadBalancer" } ] } }, "WebServerScaleUpPolicy" : { "Type" : "AWS::AutoScaling::ScalingPolicy", "Properties" : { "AdjustmentType" : "ChangeInCapacity", "AutoScalingGroupName" : { "Ref" : "WebServerGroup" }, "Cooldown" : "60", "ScalingAdjustment" : "1" } }, "WebServerScaleDownPolicy" : { "Type" : "AWS::AutoScaling::ScalingPolicy", "Properties" : { "AdjustmentType" : "ChangeInCapacity", "AutoScalingGroupName" : { "Ref" : "WebServerGroup" }, "Cooldown" : "60", "ScalingAdjustment" : "-1" } }, "ElasticLoadBalancer" : { "Type" : "AWS::ElasticLoadBalancing::LoadBalancer", "Properties" : { "AvailabilityZones" : ["nova"], "Listeners" : [ { "LoadBalancerPort" : "80", "InstancePort" : "80", "Protocol" : "HTTP" }] } }, "LaunchConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : {"Ref": "ImageId"}, "InstanceType" : "bar", } } } } ''' as_template_bad_group = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Parameters" : { "ImageId": {"Type": "String"}, "KeyName": {"Type": "String"} }, "Resources" : { "WebServerScaleUpPolicy" : { "Type" : "AWS::AutoScaling::ScalingPolicy", "Properties" : { "AdjustmentType" : "ChangeInCapacity", "AutoScalingGroupName" : "not a real group", "Cooldown" : "60", "ScalingAdjustment" : "1" } } } } ''' class AutoScalingTest(HeatTestCase): dummy_instance_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' params = {'KeyName': 'test', 'ImageId': 'foo'} def setUp(self): super(AutoScalingTest, self).setUp() utils.setup_dummy_db() cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() def create_scaling_group(self, t, stack, resource_name): # create the launch configuration resource conf = stack['LaunchConfig'] self.assertIsNone(conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) # create the group resource rsrc = stack[resource_name] self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_scaling_policy(self, t, stack, resource_name): rsrc = stack[resource_name] self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def _stub_validate(self): self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate().MultipleTimes() def _stub_create(self, num): self._stub_validate() self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) cookie = object() for x in range(num): instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(False) instance.Instance.check_create_complete( cookie).MultipleTimes().AndReturn(True) def _stub_lb_reload(self, num, unset=True, nochange=False): expected_list = [self.dummy_instance_id] * num if unset: self.m.VerifyAll() self.m.UnsetStubs() if num > 0: self.m.StubOutWithMock(instance.Instance, 'FnGetRefId') instance.Instance.FnGetRefId().MultipleTimes().AndReturn( self.dummy_instance_id) if not nochange: self.m.StubOutWithMock(loadbalancer.LoadBalancer, 'handle_update') loadbalancer.LoadBalancer.handle_update( mox.IgnoreArg(), mox.IgnoreArg(), {'Instances': expected_list}).AndReturn(None) def _stub_scale_notification(self, adjust, groupname, start_capacity, adjust_type='ChangeInCapacity', end_capacity=None, with_error=None): self.m.StubOutWithMock(notification, 'send') notification.send(stack=mox.IgnoreArg(), adjustment=adjust, adjustment_type=adjust_type, capacity=start_capacity, groupname=mox.IgnoreArg(), suffix='start', message="Start resizing the group %s" % groupname, ).AndReturn(False) if with_error: notification.send(stack=mox.IgnoreArg(), adjustment=adjust, capacity=start_capacity, adjustment_type=adjust_type, groupname=mox.IgnoreArg(), message='Nested stack update failed:' ' Error: %s' % with_error, suffix='error', ).AndReturn(False) else: notification.send(stack=mox.IgnoreArg(), adjustment=adjust, adjustment_type=adjust_type, capacity=end_capacity, groupname=mox.IgnoreArg(), message="End resizing the group %s" % groupname, suffix='end', ).AndReturn(False) def _stub_meta_expected(self, now, data, nmeta=1): # Stop time at now self.m.StubOutWithMock(timeutils, 'utcnow') timeutils.utcnow().MultipleTimes().AndReturn(now) # Then set a stub to ensure the metadata update is as # expected based on the timestamp and data self.m.StubOutWithMock(Metadata, '__set__') expected = {timeutils.strtime(now): data} # Note for ScalingPolicy, we expect to get a metadata # update for the policy and autoscaling group, so pass nmeta=2 for x in range(nmeta): Metadata.__set__(mox.IgnoreArg(), expected).AndReturn(None) def test_scaling_delete_empty(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '0' properties['MaxSize'] = '0' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(0) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertIsNone(rsrc.FnGetAtt("InstanceList")) rsrc.delete() self.m.VerifyAll() def test_scaling_adjust_down_empty(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '1' properties['MaxSize'] = '1' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') instance_names = rsrc.get_instance_names() self.assertEqual(1, len(instance_names)) # Reduce the min size to 0, should complete without adjusting update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['MinSize'] = '0' scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(instance_names, rsrc.get_instance_names()) # trigger adjustment to reduce to 0, there should be no more instances self._stub_lb_reload(0) self._stub_scale_notification(adjust=-1, groupname=rsrc.FnGetRefId(), start_capacity=1, end_capacity=0) self._stub_meta_expected(now, 'ChangeInCapacity : -1') self.m.ReplayAll() rsrc.adjust(-1) self.assertEqual([], rsrc.get_instance_names()) rsrc.delete() self.m.VerifyAll() def test_scaling_group_update_replace(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['AvailabilityZones'] = ['foo'] updater = scheduler.TaskRunner(rsrc.update, update_snippet) self.assertRaises(resource.UpdateReplace, updater) rsrc.delete() self.m.VerifyAll() def test_scaling_group_suspend(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(instance.Instance, 'handle_suspend') self.m.StubOutWithMock(instance.Instance, 'check_suspend_complete') inst_cookie = (object(), object(), object()) instance.Instance.handle_suspend().AndReturn(inst_cookie) instance.Instance.check_suspend_complete(inst_cookie).AndReturn(False) instance.Instance.check_suspend_complete(inst_cookie).AndReturn(True) self.m.ReplayAll() scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() def test_scaling_group_resume(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(instance.Instance, 'handle_resume') self.m.StubOutWithMock(instance.Instance, 'check_resume_complete') inst_cookie = (object(), object(), object()) instance.Instance.handle_resume().AndReturn(inst_cookie) instance.Instance.check_resume_complete(inst_cookie).AndReturn(False) instance.Instance.check_resume_complete(inst_cookie).AndReturn(True) self.m.ReplayAll() rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) for i in rsrc.nested().values(): i.state_set(rsrc.SUSPEND, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() def test_scaling_group_suspend_multiple(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(2, len(rsrc.get_instance_names())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(instance.Instance, 'handle_suspend') self.m.StubOutWithMock(instance.Instance, 'check_suspend_complete') inst_cookie1 = ('foo1', 'foo2', 'foo3') inst_cookie2 = ('bar1', 'bar2', 'bar3') instance.Instance.handle_suspend().InAnyOrder().AndReturn(inst_cookie1) instance.Instance.handle_suspend().InAnyOrder().AndReturn(inst_cookie2) instance.Instance.check_suspend_complete(inst_cookie1).InAnyOrder( ).AndReturn(True) instance.Instance.check_suspend_complete(inst_cookie2).InAnyOrder( ).AndReturn(True) self.m.ReplayAll() scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() def test_scaling_group_resume_multiple(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(2, len(rsrc.get_instance_names())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(instance.Instance, 'handle_resume') self.m.StubOutWithMock(instance.Instance, 'check_resume_complete') inst_cookie1 = ('foo1', 'foo2', 'foo3') inst_cookie2 = ('bar1', 'bar2', 'bar3') instance.Instance.handle_resume().InAnyOrder().AndReturn(inst_cookie1) instance.Instance.handle_resume().InAnyOrder().AndReturn(inst_cookie2) instance.Instance.check_resume_complete(inst_cookie1).InAnyOrder( ).AndReturn(True) instance.Instance.check_resume_complete(inst_cookie2).InAnyOrder( ).AndReturn(True) self.m.ReplayAll() rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) for i in rsrc.nested().values(): i.state_set(rsrc.SUSPEND, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() def test_scaling_group_suspend_fail(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(instance.Instance, 'handle_suspend') self.m.StubOutWithMock(instance.Instance, 'check_suspend_complete') instance.Instance.handle_suspend().AndRaise(Exception('oops')) self.m.ReplayAll() sus_task = scheduler.TaskRunner(rsrc.suspend) self.assertRaises(exception.ResourceFailure, sus_task, ()) self.assertEqual((rsrc.SUSPEND, rsrc.FAILED), rsrc.state) self.assertEqual('Error: Resource SUSPEND failed: Exception: oops', rsrc.status_reason) rsrc.delete() self.m.VerifyAll() def test_scaling_group_resume_fail(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(instance.Instance, 'handle_resume') self.m.StubOutWithMock(instance.Instance, 'check_resume_complete') instance.Instance.handle_resume().AndRaise(Exception('oops')) self.m.ReplayAll() rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) for i in rsrc.nested().values(): i.state_set(rsrc.SUSPEND, rsrc.COMPLETE) sus_task = scheduler.TaskRunner(rsrc.resume) self.assertRaises(exception.ResourceFailure, sus_task, ()) self.assertEqual((rsrc.RESUME, rsrc.FAILED), rsrc.state) self.assertEqual('Error: Resource RESUME failed: Exception: oops', rsrc.status_reason) rsrc.delete() self.m.VerifyAll() def test_scaling_group_create_error(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_validate() self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') instance.Instance.handle_create().AndRaise(Exception) self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() conf = stack['LaunchConfig'] self.assertIsNone(conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) rsrc = stack['WebServerGroup'] self.assertIsNone(rsrc.validate()) self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.assertEqual([], rsrc.get_instance_names()) self.m.VerifyAll() def test_scaling_group_update_ok_maxsize(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '1' properties['MaxSize'] = '3' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(1, len(rsrc.get_instance_names())) instance_names = rsrc.get_instance_names() # Reduce the max size to 2, should complete without adjusting update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['MaxSize'] = '2' scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(instance_names, rsrc.get_instance_names()) self.assertEqual(2, rsrc.properties['MaxSize']) rsrc.delete() self.m.VerifyAll() def test_scaling_group_update_ok_minsize(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '1' properties['MaxSize'] = '3' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(1, len(rsrc.get_instance_names())) # Increase min size to 2, should trigger an ExactCapacity adjust self._stub_lb_reload(2) self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(1) self.m.ReplayAll() update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['MinSize'] = '2' scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(2, len(rsrc.get_instance_names())) self.assertEqual(2, rsrc.properties['MinSize']) rsrc.delete() self.m.VerifyAll() def test_scaling_group_update_ok_desired(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '1' properties['MaxSize'] = '3' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(1, len(rsrc.get_instance_names())) # Increase min size to 2 via DesiredCapacity, should adjust self._stub_lb_reload(2) self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(1) self.m.ReplayAll() update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['DesiredCapacity'] = '2' scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(2, len(rsrc.get_instance_names())) self.assertEqual(2, rsrc.properties['DesiredCapacity']) rsrc.delete() self.m.VerifyAll() def test_scaling_group_update_ok_desired_remove(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(2, len(rsrc.get_instance_names())) instance_names = rsrc.get_instance_names() # Remove DesiredCapacity from the updated template, which should # have no effect, it's an optional parameter update_snippet = copy.deepcopy(rsrc.parsed_template()) del(update_snippet['Properties']['DesiredCapacity']) scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(instance_names, rsrc.get_instance_names()) self.assertIsNone(rsrc.properties['DesiredCapacity']) rsrc.delete() self.m.VerifyAll() def test_scaling_group_update_ok_cooldown(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['Cooldown'] = '60' stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['Cooldown'] = '61' scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(61, rsrc.properties['Cooldown']) rsrc.delete() self.m.VerifyAll() def test_lb_reload_static_resolve(self): t = template_format.parse(as_template) properties = t['Resources']['ElasticLoadBalancer']['Properties'] properties['AvailabilityZones'] = {'Fn::GetAZs': ''} self.m.StubOutWithMock(parser.Stack, 'get_availability_zones') parser.Stack.get_availability_zones().MultipleTimes().AndReturn( ['abc', 'xyz']) # Check that the Fn::GetAZs is correctly resolved expected = {u'Type': u'AWS::ElasticLoadBalancing::LoadBalancer', u'Properties': {'Instances': ['aaaabbbbcccc'], u'Listeners': [{u'InstancePort': u'80', u'LoadBalancerPort': u'80', u'Protocol': u'HTTP'}], u'AvailabilityZones': ['abc', 'xyz']}} self.m.StubOutWithMock(short_id, 'generate_id') short_id.generate_id().AndReturn('aaaabbbbcccc') now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() stack = utils.parse_stack(t, params=self.params) lb = stack['ElasticLoadBalancer'] self.m.StubOutWithMock(lb, 'handle_update') lb.handle_update(expected, mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(None) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(rsrc.get_instance_names())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['Cooldown'] = '61' scheduler.TaskRunner(rsrc.update, update_snippet)() rsrc.delete() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') def test_lb_reload_members(self): t = template_format.parse(as_template) t['Resources']['ElasticLoadBalancer'] = { 'Type': 'OS::Neutron::LoadBalancer', 'Properties': { 'protocol_port': 8080, 'pool_id': 'pool123' } } expected = { 'Type': 'OS::Neutron::LoadBalancer', 'Properties': { 'protocol_port': 8080, 'pool_id': 'pool123', 'members': [u'aaaabbbbcccc']} } self.m.StubOutWithMock(short_id, 'generate_id') short_id.generate_id().AndReturn('aaaabbbbcccc') self.m.StubOutWithMock(neutron_lb.LoadBalancer, 'handle_update') neutron_lb.LoadBalancer.handle_update(expected, mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(None) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() stack = utils.parse_stack(t, params=self.params) self.create_scaling_group(t, stack, 'WebServerGroup') self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') def test_lb_reload_invalid_resource(self): t = template_format.parse(as_template) t['Resources']['ElasticLoadBalancer'] = { 'Type': 'AWS::EC2::Volume', 'Properties': { 'AvailabilityZone': 'nova' } } self._stub_create(1) self.m.ReplayAll() stack = utils.parse_stack(t, params=self.params) error = self.assertRaises( exception.ResourceFailure, self.create_scaling_group, t, stack, 'WebServerGroup') self.assertEqual( "Error: Unsupported resource 'ElasticLoadBalancer' in " "LoadBalancerNames", str(error)) self.m.VerifyAll() def test_scaling_group_adjust(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # start with 3 properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '3' self._stub_lb_reload(3) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 3') self._stub_create(3) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(3, len(rsrc.get_instance_names())) # reduce to 1 self._stub_lb_reload(1) self._stub_validate() self._stub_meta_expected(now, 'ChangeInCapacity : -2') self._stub_scale_notification(adjust=-2, groupname=rsrc.FnGetRefId(), start_capacity=3, end_capacity=1) self.m.ReplayAll() rsrc.adjust(-2) self.assertEqual(1, len(rsrc.get_instance_names())) # raise to 3 self._stub_lb_reload(3) self._stub_meta_expected(now, 'ChangeInCapacity : 2') self._stub_create(2) self._stub_scale_notification(adjust=2, groupname=rsrc.FnGetRefId(), start_capacity=1, end_capacity=3) self.m.ReplayAll() rsrc.adjust(2) self.assertEqual(3, len(rsrc.get_instance_names())) # set to 2 self._stub_lb_reload(2) self._stub_validate() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_scale_notification(adjust=2, groupname=rsrc.FnGetRefId(), adjust_type='ExactCapacity', start_capacity=3, end_capacity=2) self.m.ReplayAll() rsrc.adjust(2, 'ExactCapacity') self.assertEqual(2, len(rsrc.get_instance_names())) self.m.VerifyAll() def test_scaling_group_scale_up_failure(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(1, len(rsrc.get_instance_names())) self.m.VerifyAll() self.m.UnsetStubs() # Scale up one 1 instance with resource failure self.m.StubOutWithMock(instance.Instance, 'handle_create') instance.Instance.handle_create().AndRaise(exception.Error('Bang')) self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self._stub_lb_reload(1, unset=False, nochange=True) self._stub_validate() self._stub_scale_notification(adjust=1, groupname=rsrc.FnGetRefId(), start_capacity=1, with_error='Bang') self.m.ReplayAll() self.assertRaises(exception.Error, rsrc.adjust, 1) self.assertEqual(1, len(rsrc.get_instance_names())) self.m.VerifyAll() def test_scaling_group_truncate_adjustment(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group, 2 instances properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(2, len(rsrc.get_instance_names())) # raise above the max self._stub_lb_reload(5) self._stub_meta_expected(now, 'ChangeInCapacity : 4') self._stub_create(3) self.m.ReplayAll() rsrc.adjust(4) self.assertEqual(5, len(rsrc.get_instance_names())) # lower below the min self._stub_lb_reload(1) self._stub_validate() self._stub_meta_expected(now, 'ChangeInCapacity : -5') self.m.ReplayAll() rsrc.adjust(-5) self.assertEqual(1, len(rsrc.get_instance_names())) # no change rsrc.adjust(0) self.assertEqual(1, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def _do_test_scaling_group_percent(self, decrease, lowest, increase, create, highest): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group, 2 instances properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' self._stub_lb_reload(2) self._stub_create(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by decrease % self._stub_lb_reload(lowest) adjust = 'PercentChangeInCapacity : %d' % decrease self._stub_meta_expected(now, adjust) self._stub_validate() self.m.ReplayAll() rsrc.adjust(decrease, 'PercentChangeInCapacity') self.assertEqual(lowest, len(rsrc.get_instance_names())) # raise by increase % self._stub_lb_reload(highest) adjust = 'PercentChangeInCapacity : %d' % increase self._stub_meta_expected(now, adjust) self._stub_create(create) self.m.ReplayAll() rsrc.adjust(increase, 'PercentChangeInCapacity') self.assertEqual(highest, len(rsrc.get_instance_names())) rsrc.delete() def test_scaling_group_percent(self): self._do_test_scaling_group_percent(-50, 1, 200, 2, 3) def test_scaling_group_percent_round_up(self): self._do_test_scaling_group_percent(-33, 1, 33, 1, 2) def test_scaling_group_percent_round_down(self): self._do_test_scaling_group_percent(-66, 1, 225, 2, 3) def test_scaling_group_cooldown_toosoon(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group, 2 instances, Cooldown 60s properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' properties['Cooldown'] = '60' self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by 50% self._stub_lb_reload(1) self._stub_validate() self._stub_meta_expected(now, 'PercentChangeInCapacity : -50') self.m.ReplayAll() rsrc.adjust(-50, 'PercentChangeInCapacity') self.assertEqual(1, len(rsrc.get_instance_names())) # Now move time on 10 seconds - Cooldown in template is 60 # so this should not update the policy metadata, and the # scaling group instances should be unchanged # Note we have to stub Metadata.__get__ since up_policy isn't # stored in the DB (because the stack hasn't really been created) previous_meta = {timeutils.strtime(now): 'PercentChangeInCapacity : -50'} self.m.VerifyAll() self.m.UnsetStubs() now = now + datetime.timedelta(seconds=10) self.m.StubOutWithMock(timeutils, 'utcnow') timeutils.utcnow().MultipleTimes().AndReturn(now) self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) self.m.ReplayAll() # raise by 200%, too soon for Cooldown so there should be no change rsrc.adjust(200, 'PercentChangeInCapacity') self.assertEqual(1, len(rsrc.get_instance_names())) rsrc.delete() def test_scaling_group_cooldown_ok(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group, 2 instances, Cooldown 60s properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' properties['Cooldown'] = '60' self._stub_lb_reload(2) self._stub_create(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by 50% self._stub_lb_reload(1) self._stub_validate() self._stub_meta_expected(now, 'PercentChangeInCapacity : -50') self.m.ReplayAll() rsrc.adjust(-50, 'PercentChangeInCapacity') self.assertEqual(1, len(rsrc.get_instance_names())) # Now move time on 61 seconds - Cooldown in template is 60 # so this should update the policy metadata, and the # scaling group instances updated previous_meta = {timeutils.strtime(now): 'PercentChangeInCapacity : -50'} self.m.VerifyAll() self.m.UnsetStubs() now = now + datetime.timedelta(seconds=61) self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) #stub for the metadata accesses while creating the two instances Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) # raise by 200%, should work self._stub_lb_reload(3, unset=False) self._stub_create(2) self._stub_meta_expected(now, 'PercentChangeInCapacity : 200') self.m.ReplayAll() rsrc.adjust(200, 'PercentChangeInCapacity') self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() def test_scaling_group_cooldown_zero(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group, 2 instances, Cooldown 0 properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' properties['Cooldown'] = '0' self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by 50% self._stub_lb_reload(1) self._stub_meta_expected(now, 'PercentChangeInCapacity : -50') self._stub_validate() self.m.ReplayAll() rsrc.adjust(-50, 'PercentChangeInCapacity') self.assertEqual(1, len(rsrc.get_instance_names())) # Don't move time, since cooldown is zero, it should work previous_meta = {timeutils.strtime(now): 'PercentChangeInCapacity : -50'} self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) #stub for the metadata accesses while creating the two instances Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) # raise by 200%, should work self._stub_lb_reload(3, unset=False) self._stub_meta_expected(now, 'PercentChangeInCapacity : 200') self._stub_create(2) self.m.ReplayAll() rsrc.adjust(200, 'PercentChangeInCapacity') self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_bad_group(self): t = template_format.parse(as_template_bad_group) stack = utils.parse_stack(t, params=self.params) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') alarm_url = up_policy.FnGetAtt('AlarmUrl') self.assertIsNotNone(alarm_url) ex = self.assertRaises(exception.ResourceFailure, up_policy.signal) self.assertIn('Alarm WebServerScaleUpPolicy could ' 'not find scaling group', str(ex)) self.m.VerifyAll() def test_scaling_policy_up(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') alarm_url = up_policy.FnGetAtt('AlarmUrl') self.assertIsNotNone(alarm_url) up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_up_meta_update(self): t = template_format.parse(as_template) # Add CustomLB (just AWS::EC2::Instance) to template t['Resources']['MyCustomLB'] = { 'Type': 'AWS::EC2::Instance', 'ImageId': {'Ref': 'ImageId'}, 'InstanceType': 'bar', 'Metadata': { 'IPs': {'Fn::GetAtt': ['WebServerGroup', 'InstanceList']} } } stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') alarm_url = up_policy.FnGetAtt('AlarmUrl') self.assertIsNotNone(alarm_url) up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) # Check CustomLB metadata was updated self.m.StubOutWithMock(instance.Instance, '_ipaddress') instance.Instance._ipaddress().MultipleTimes().AndReturn( '127.0.0.1') self.m.ReplayAll() expected_meta = {'IPs': u'127.0.0.1,127.0.0.1'} self.assertEqual(expected_meta, stack['MyCustomLB'].metadata) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_down(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group, 2 instances properties = t['Resources']['WebServerGroup']['Properties'] properties['DesiredCapacity'] = '2' self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 2') self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(2, len(rsrc.get_instance_names())) # Scale down one self._stub_lb_reload(1) self._stub_validate() self._stub_meta_expected(now, 'ChangeInCapacity : -1', 2) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() down_policy = self.create_scaling_policy(t, stack, 'WebServerScaleDownPolicy') down_policy.signal() self.assertEqual(1, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_cooldown_toosoon(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) # Now move time on 10 seconds - Cooldown in template is 60 # so this should not update the policy metadata, and the # scaling group instances should be unchanged # Note we have to stub Metadata.__get__ since up_policy isn't # stored in the DB (because the stack hasn't really been created) previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} self.m.VerifyAll() self.m.UnsetStubs() now = now + datetime.timedelta(seconds=10) self.m.StubOutWithMock(timeutils, 'utcnow') timeutils.utcnow().MultipleTimes().AndReturn(now) self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg() ).AndReturn(previous_meta) self.m.ReplayAll() up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_cooldown_ok(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) # Now move time on 61 seconds - Cooldown in template is 60 # so this should trigger a scale-up previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg() ).AndReturn(previous_meta) Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) #stub for the metadata accesses while creating the additional instance Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) now = now + datetime.timedelta(seconds=61) self._stub_lb_reload(3, unset=False) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.ReplayAll() up_policy.signal() self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_cooldown_zero(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Create the scaling policy (with Cooldown=0) and scale up one properties = t['Resources']['WebServerScaleUpPolicy']['Properties'] properties['Cooldown'] = '0' self._stub_lb_reload(2) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) # Now trigger another scale-up without changing time, should work previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg() ).AndReturn(previous_meta) Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) #stub for the metadata accesses while creating the additional instance Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) self._stub_lb_reload(3, unset=False) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.ReplayAll() up_policy.signal() self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_cooldown_none(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Create the scaling policy no Cooldown property, should behave the # same as when Cooldown==0 properties = t['Resources']['WebServerScaleUpPolicy']['Properties'] del(properties['Cooldown']) self._stub_lb_reload(2) now = timeutils.utcnow() self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) # Now trigger another scale-up without changing time, should work previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg() ).AndReturn(previous_meta) Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) #stub for the metadata accesses while creating the additional instance Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) self._stub_lb_reload(3, unset=False) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.ReplayAll() up_policy.signal() self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_scaling_policy_update(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) # Create initial group self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.StubOutWithMock(asc.ScalingPolicy, 'keystone') asc.ScalingPolicy.keystone().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc self.assertEqual(1, len(rsrc.get_instance_names())) # Create initial scaling policy up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') # Scale up one self._stub_lb_reload(2) self._stub_meta_expected(now, 'ChangeInCapacity : 1', 2) self._stub_create(1) self.m.ReplayAll() # Trigger alarm up_policy.signal() self.assertEqual(2, len(rsrc.get_instance_names())) # Update scaling policy update_snippet = copy.deepcopy(up_policy.parsed_template()) update_snippet['Properties']['ScalingAdjustment'] = '2' scheduler.TaskRunner(up_policy.update, update_snippet)() self.assertEqual(2, up_policy.properties['ScalingAdjustment']) # Now move time on 61 seconds - Cooldown in template is 60 # so this should trigger a scale-up previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(Metadata, '__get__') Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg() ).AndReturn(previous_meta) Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg() ).AndReturn(previous_meta) #stub for the metadata accesses while creating the two instances Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) Metadata.__get__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) now = now + datetime.timedelta(seconds=61) self._stub_lb_reload(4, unset=False) self._stub_meta_expected(now, 'ChangeInCapacity : 2', 2) self._stub_create(2) self.m.ReplayAll() # Trigger alarm up_policy.signal() self.assertEqual(4, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() def test_vpc_zone_identifier(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['VPCZoneIdentifier'] = ['xxxx'] stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') instances = rsrc.get_instances() self.assertEqual(1, len(instances)) self.assertEqual('xxxx', instances[0].properties['SubnetId']) rsrc.delete() self.m.VerifyAll() def test_invalid_vpc_zone_identifier(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['VPCZoneIdentifier'] = ['xxxx', 'yyyy'] stack = utils.parse_stack(t, params=self.params) self.assertRaises(exception.NotSupported, self.create_scaling_group, t, stack, 'WebServerGroup') def test_invalid_min_size(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '-1' properties['MaxSize'] = '2' stack = utils.parse_stack(t, params=self.params) e = self.assertRaises(exception.StackValidationFailed, self.create_scaling_group, t, stack, 'WebServerGroup') expected_msg = "The size of AutoScalingGroup can not be less than zero" self.assertEqual(expected_msg, str(e)) def test_invalid_max_size(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '3' properties['MaxSize'] = '1' stack = utils.parse_stack(t, params=self.params) e = self.assertRaises(exception.StackValidationFailed, self.create_scaling_group, t, stack, 'WebServerGroup') expected_msg = "MinSize can not be greater than MaxSize" self.assertEqual(expected_msg, str(e)) def test_invalid_desiredcapacity(self): t = template_format.parse(as_template) properties = t['Resources']['WebServerGroup']['Properties'] properties['MinSize'] = '1' properties['MaxSize'] = '3' properties['DesiredCapacity'] = '4' stack = utils.parse_stack(t, params=self.params) e = self.assertRaises(exception.StackValidationFailed, self.create_scaling_group, t, stack, 'WebServerGroup') expected_msg = "DesiredCapacity must be between MinSize and MaxSize" self.assertEqual(expected_msg, str(e)) class TestInstanceGroup(HeatTestCase): params = {'KeyName': 'test', 'ImageId': 'foo'} def setUp(self): super(TestInstanceGroup, self).setUp() utils.setup_dummy_db() json_snippet = {'Properties': {'Size': 2, 'LaunchConfigurationName': 'foo'}} t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self.instance_group = asc.InstanceGroup('ig', json_snippet, stack) def test_child_template(self): self.instance_group._create_template = mock.Mock(return_value='tpl') self.assertEqual('tpl', self.instance_group.child_template()) self.instance_group._create_template.assert_called_once_with(2) def test_child_params(self): self.instance_group._environment = mock.Mock(return_value='env') self.assertEqual('env', self.instance_group.child_params()) heat-2014.1.5/heat/tests/test_neutron_metering.py0000664000567000056700000002602312540642614023114 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. from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.resources.neutron import metering from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils neutronclient = try_import('neutronclient.v2_0.client') metering_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test metering resources", "Parameters" : {}, "Resources" : { "label": { "Type": "OS::Neutron::MeteringLabel", "Properties": { "name": "TestLabel", "description": "Description of TestLabel" } }, "rule": { "Type": "OS::Neutron::MeteringRule", "Properties": { "metering_label_id": { "Ref" : "label" }, "remote_ip_prefix": "10.0.3.0/24", "direction": "ingress", "excluded": false } } } } ''' @skipIf(neutronclient is None, 'neutronclient unavailable') class MeteringLabelTest(HeatTestCase): def setUp(self): super(MeteringLabelTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_metering_label') self.m.StubOutWithMock(neutronclient.Client, 'delete_metering_label') self.m.StubOutWithMock(neutronclient.Client, 'show_metering_label') self.m.StubOutWithMock(neutronclient.Client, 'create_metering_label_rule') self.m.StubOutWithMock(neutronclient.Client, 'delete_metering_label_rule') self.m.StubOutWithMock(neutronclient.Client, 'show_metering_label_rule') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_metering_label(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_metering_label({ 'metering_label': { 'name': 'TestLabel', 'description': 'Description of TestLabel'} }).AndReturn({'metering_label': {'id': '1234'}}) snippet = template_format.parse(metering_template) stack = utils.parse_stack(snippet) return metering.MeteringLabel( 'label', snippet['Resources']['label'], stack) def test_create(self): rsrc = self.create_metering_label() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_metering_label({ 'metering_label': { 'name': 'TestLabel', 'description': 'Description of TestLabel'} }).AndRaise(metering.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(metering_template) stack = utils.parse_stack(snippet) rsrc = metering.MeteringLabel( 'label', snippet['Resources']['label'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete(self): neutronclient.Client.delete_metering_label('1234') neutronclient.Client.show_metering_label('1234').AndRaise( metering.NeutronClientException(status_code=404)) rsrc = self.create_metering_label() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_metering_label('1234').AndRaise( metering.NeutronClientException(status_code=404)) rsrc = self.create_metering_label() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_metering_label('1234').AndRaise( metering.NeutronClientException(status_code=400)) rsrc = self.create_metering_label() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_metering_label() neutronclient.Client.show_metering_label('1234').MultipleTimes( ).AndReturn( {'metering_label': {'name': 'TestLabel', 'description': 'Description of TestLabel'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('TestLabel', rsrc.FnGetAtt('name')) self.assertEqual('Description of TestLabel', rsrc.FnGetAtt('description')) self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class MeteringRuleTest(HeatTestCase): def setUp(self): super(MeteringRuleTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_metering_label') self.m.StubOutWithMock(neutronclient.Client, 'delete_metering_label') self.m.StubOutWithMock(neutronclient.Client, 'show_metering_label') self.m.StubOutWithMock(neutronclient.Client, 'create_metering_label_rule') self.m.StubOutWithMock(neutronclient.Client, 'delete_metering_label_rule') self.m.StubOutWithMock(neutronclient.Client, 'show_metering_label_rule') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_metering_label_rule(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_metering_label_rule({ 'metering_label_rule': { 'metering_label_id': 'None', 'remote_ip_prefix': '10.0.3.0/24', 'direction': 'ingress', 'excluded': False} }).AndReturn({'metering_label_rule': {'id': '5678'}}) snippet = template_format.parse(metering_template) stack = utils.parse_stack(snippet) return metering.MeteringRule( 'rule', snippet['Resources']['rule'], stack) def test_create(self): rsrc = self.create_metering_label_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_metering_label_rule({ 'metering_label_rule': { 'metering_label_id': 'None', 'remote_ip_prefix': '10.0.3.0/24', 'direction': 'ingress', 'excluded': False} }).AndRaise(metering.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(metering_template) stack = utils.parse_stack(snippet) rsrc = metering.MeteringRule( 'rule', snippet['Resources']['rule'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete(self): neutronclient.Client.delete_metering_label_rule('5678') neutronclient.Client.show_metering_label_rule('5678').AndRaise( metering.NeutronClientException(status_code=404)) rsrc = self.create_metering_label_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_metering_label_rule('5678').AndRaise( metering.NeutronClientException(status_code=404)) rsrc = self.create_metering_label_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_metering_label_rule('5678').AndRaise( metering.NeutronClientException(status_code=400)) rsrc = self.create_metering_label_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_metering_label_rule() neutronclient.Client.show_metering_label_rule('5678').MultipleTimes( ).AndReturn( {'metering_label_rule': {'metering_label_id': 'None', 'remote_ip_prefix': '10.0.3.0/24', 'direction': 'ingress', 'excluded': False}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('10.0.3.0/24', rsrc.FnGetAtt('remote_ip_prefix')) self.assertEqual('ingress', rsrc.FnGetAtt('direction')) self.assertIs(False, rsrc.FnGetAtt('excluded')) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_nova_keypair.py0000664000567000056700000001510512540642614022216 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. import collections import copy from novaclient import exceptions as nova_exceptions from heat.engine import clients from heat.engine.resources import nova_keypair from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes class NovaKeyPairTest(HeatTestCase): kp_template = { "heat_template_version": "2013-05-23", "resources": { "kp": { "type": "OS::Nova::KeyPair", "properties": { "name": "key_pair" } } } } def setUp(self): super(NovaKeyPairTest, self).setUp() utils.setup_dummy_db() self.fake_nova = self.m.CreateMockAnything() self.fake_keypairs = self.m.CreateMockAnything() self.fake_nova.keypairs = self.fake_keypairs def _mock_key(self, name, pub=None, priv=None): mkey = self.m.CreateMockAnything() mkey.id = name mkey.name = name if pub: mkey.public_key = pub if priv: mkey.private_key = priv return mkey def _get_test_resource(self, template): stack = utils.parse_stack(template) snippet = stack.t['Resources']['kp'] kp_res = nova_keypair.KeyPair('kp', snippet, stack) self.m.StubOutWithMock(kp_res, "nova") kp_res.nova().MultipleTimes().AndReturn(self.fake_nova) return kp_res def _get_mock_kp_for_create(self, key_name, public_key=None, priv_saved=False): template = copy.deepcopy(self.kp_template) template['resources']['kp']['properties']['name'] = key_name props = template['resources']['kp']['properties'] if public_key: props['public_key'] = public_key gen_pk = public_key or "generated test public key" nova_key = self._mock_key(key_name, gen_pk) if priv_saved: nova_key.private_key = "private key for %s" % key_name props['save_private_key'] = True kp_res = self._get_test_resource(template) self.fake_keypairs.create(key_name, public_key=public_key).AndReturn(nova_key) return kp_res, nova_key def test_create_key(self): """Test basic create.""" key_name = "generate_no_save" tp_test, created_key = self._get_mock_kp_for_create(key_name) self.fake_keypairs.list().AndReturn([created_key]) self.m.ReplayAll() scheduler.TaskRunner(tp_test.create)() self.assertEqual("", tp_test.FnGetAtt('private_key')) self.assertEqual("generated test public key", tp_test.FnGetAtt('public_key')) self.assertEqual((tp_test.CREATE, tp_test.COMPLETE), tp_test.state) self.assertEqual(tp_test.resource_id, created_key.name) self.m.VerifyAll() def test_delete_key(self): """Test basic delete.""" test_res = self._get_test_resource(self.kp_template) test_res.resource_id = "key_name" test_res.state_set(test_res.CREATE, test_res.COMPLETE) self.fake_keypairs.delete("key_name").AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(test_res.delete)() self.assertEqual((test_res.DELETE, test_res.COMPLETE), test_res.state) self.m.VerifyAll() def test_delete_key_not_found(self): """Test delete non-existant key.""" test_res = self._get_test_resource(self.kp_template) test_res.resource_id = "key_name" test_res.state_set(test_res.CREATE, test_res.COMPLETE) (self.fake_keypairs.delete("key_name") .AndRaise(nova_exceptions.NotFound(404))) self.m.ReplayAll() scheduler.TaskRunner(test_res.delete)() self.assertEqual((test_res.DELETE, test_res.COMPLETE), test_res.state) self.m.VerifyAll() def test_create_pub(self): """Test create using existing pub key.""" key_name = "existing_key" pk = "test_create_pub" tp_test, created_key = self._get_mock_kp_for_create(key_name, public_key=pk) self.m.ReplayAll() scheduler.TaskRunner(tp_test.create)() self.assertEqual("", tp_test.FnGetAtt('private_key')) self.assertEqual("test_create_pub", tp_test.FnGetAtt('public_key')) self.assertEqual((tp_test.CREATE, tp_test.COMPLETE), tp_test.state) self.assertEqual(tp_test.resource_id, created_key.name) self.m.VerifyAll() def test_save_priv_key(self): """Test a saved private key.""" key_name = "save_private" tp_test, created_key = self._get_mock_kp_for_create(key_name, priv_saved=True) self.fake_keypairs.list().AndReturn([created_key]) self.m.ReplayAll() scheduler.TaskRunner(tp_test.create)() self.assertEqual("private key for save_private", tp_test.FnGetAtt('private_key')) self.assertEqual("generated test public key", tp_test.FnGetAtt('public_key')) self.assertEqual((tp_test.CREATE, tp_test.COMPLETE), tp_test.state) self.assertEqual(tp_test.resource_id, created_key.name) self.m.VerifyAll() class KeypairConstraintTest(HeatTestCase): def test_validation(self): client = fakes.FakeClient() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(client) client.keypairs = self.m.CreateMockAnything() key = collections.namedtuple("Key", ["name"]) key.name = "foo" client.keypairs.list().MultipleTimes().AndReturn([key]) self.m.ReplayAll() constraint = nova_keypair.KeypairConstraint() self.assertFalse(constraint.validate("bar", None)) self.assertTrue(constraint.validate("foo", None)) self.assertTrue(constraint.validate("", None)) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_swift.py0000664000567000056700000002601312540642614020663 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. import mox from testtools import skipIf from heat.common import template_format from heat.engine import clients from heat.engine import resource from heat.engine.resources import swift from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils swiftclient = try_import('swiftclient.client') swift_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test OS::Swift::Container resources", "Resources" : { "SwiftContainerWebsite" : { "Type" : "OS::Swift::Container", "DeletionPolicy" : "Delete", "Properties" : { "X-Container-Read" : ".r:*", "X-Container-Meta" : { "Web-Index" : "index.html", "Web-Error" : "error.html" } } }, "SwiftAccountMetadata" : { "Type" : "OS::Swift::Container", "DeletionPolicy" : "Delete", "Properties" : { "X-Account-Meta" : { "Temp-Url-Key" : "secret" } } }, "S3Bucket" : { "Type" : "AWS::S3::Bucket", "Properties" : { "SwiftContainer" : {"Ref" : "SwiftContainer"} } }, "SwiftContainer" : { "Type" : "OS::Swift::Container", "Properties" : { } } } } ''' class swiftTest(HeatTestCase): @skipIf(swiftclient is None, 'unable to import swiftclient') def setUp(self): super(swiftTest, self).setUp() self.m.CreateMock(swiftclient.Connection) self.m.StubOutWithMock(swiftclient.Connection, 'post_account') self.m.StubOutWithMock(swiftclient.Connection, 'put_container') self.m.StubOutWithMock(swiftclient.Connection, 'delete_container') self.m.StubOutWithMock(swiftclient.Connection, 'head_container') self.m.StubOutWithMock(swiftclient.Connection, 'get_auth') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_resource(self, t, stack, resource_name): rsrc = swift.SwiftContainer( 'test_resource', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_create_container_name(self): self.m.ReplayAll() t = template_format.parse(swift_template) t['Resources']['SwiftContainer']['Properties']['name'] = 'the_name' stack = utils.parse_stack(t) rsrc = swift.SwiftContainer( 'test_resource', t['Resources']['SwiftContainer'], stack) self.assertEqual('the_name', rsrc.physical_resource_name()) def test_build_meta_headers(self): self.m.UnsetStubs() self.assertEqual({}, swift.SwiftContainer._build_meta_headers( 'container', {})) self.assertEqual({}, swift.SwiftContainer._build_meta_headers( 'container', None)) meta = { 'X-Container-Meta-Web-Index': 'index.html', 'X-Container-Meta-Web-Error': 'error.html' } self.assertEqual(meta, swift.SwiftContainer._build_meta_headers( 'container', { "Web-Index": "index.html", "Web-Error": "error.html" })) def test_attributes(self): headers = { "content-length": "0", "x-container-object-count": "82", "accept-ranges": "bytes", "x-trans-id": "tx08ea48ef2fa24e6da3d2f5c188fd938b", "date": "Wed, 23 Jan 2013 22:48:05 GMT", "x-timestamp": "1358980499.84298", "x-container-read": ".r:*", "x-container-bytes-used": "17680980", "content-type": "text/plain; charset=utf-8"} clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {}).AndReturn(None) swiftclient.Connection.head_container( mox.IgnoreArg()).MultipleTimes().AndReturn(headers) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') ref_id = rsrc.FnGetRefId() self.assertEqual(container_name, ref_id) self.assertEqual('example.com', rsrc.FnGetAtt('DomainName')) url = 'http://example.com:1234/v1/%s' % ref_id self.assertEqual(url, rsrc.FnGetAtt('WebsiteURL')) self.assertEqual('82', rsrc.FnGetAtt('ObjectCount')) self.assertEqual('17680980', rsrc.FnGetAtt('BytesUsed')) self.assertEqual(headers, rsrc.FnGetAtt('HeadContainer')) self.assertRaises(swift.exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_public_read(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Read': '.r:*'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) properties = t['Resources']['SwiftContainer']['Properties'] properties['X-Container-Read'] = '.r:*' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_public_read_write(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Write': '.r:*', 'X-Container-Read': '.r:*'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) properties = t['Resources']['SwiftContainer']['Properties'] properties['X-Container-Read'] = '.r:*' properties['X-Container-Write'] = '.r:*' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_container_headers(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Meta-Web-Error': 'error.html', 'X-Container-Meta-Web-Index': 'index.html', 'X-Container-Read': '.r:*'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainerWebsite') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_account_headers(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container(container_name, {}) swiftclient.Connection.post_account( {'X-Account-Meta-Temp-Url-Key': 'secret'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftAccountMetadata') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_delete_exception(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndRaise( swiftclient.ClientException('Test delete failure')) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_delete_retain(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) # first run, with retain policy swiftclient.Connection.put_container( utils.PhysName('test_stack', 'test_resource'), {}).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) container = t['Resources']['SwiftContainer'] container['DeletionPolicy'] = 'Retain' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_default_headers_not_none_empty_string(self): '''Test that we are not passing None when we have a default empty string or swiftclient will pass them as string None. see bug lp:1259571. ''' clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() self.assertEqual({}, rsrc.metadata) heat-2014.1.5/heat/tests/test_os_database.py0000664000567000056700000003163312540642614022000 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. import uuid from heat.common import exception from heat.common import template_format from heat.engine.clients import troveclient from heat.engine import environment from heat.engine import parser from heat.engine.resources import os_database from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils wp_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "MySQL instance running on openstack DBaaS cloud", "Parameters" : { "flavor": { "Description" : "Flavor reference", "Type": "String", "Default": '1GB' }, "size": { "Description" : "The volume size", "Type": "Number", "Default": '30' }, "name": { "Description" : "The database instance name", "Type": "String", "Default": "OpenstackDbaas" } }, "Resources" : { "MySqlCloudDB": { "Type": "OS::Trove::Instance", "Properties" : { "name" : "test", "flavor" : "1GB", "size" : 30, "users" : [{"name": "testuser", "password": "pass", "databases": ["validdb"]}], "databases" : [{"name": "validdb"}] } } } } ''' class FakeDBInstance(object): def __init__(self): self.id = 12345 self.hostname = "testhost" self.links = [ {"href": "https://adga23dd432a.rackspacecloud.com/132345245", "rel": "self"}] self.resource_id = 12345 self.status = 'ACTIVE' def get(self): pass def delete(self): pass class FakeFlavor(object): def __init__(self, id, name): self.id = id self.name = name class OSDBInstanceTest(HeatTestCase): def setUp(self): super(OSDBInstanceTest, self).setUp() self.fc = self.m.CreateMockAnything() utils.setup_dummy_db() def _setup_test_clouddbinstance(self, name, parsed_t): stack_name = '%s_stack' % name t = parsed_t template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'name': 'test'}), stack_id=str(uuid.uuid4())) instance = os_database.OSDBInstance( '%s_name' % name, t['Resources']['MySqlCloudDB'], stack) instance.t = instance.stack.resolve_runtime_data(instance.t) return instance def _stubout_create(self, instance, fake_dbinstance): self.m.StubOutWithMock(instance, 'trove') instance.trove().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc, 'flavors') self.m.StubOutWithMock(self.fc.flavors, "list") self.fc.flavors.list().AndReturn([FakeFlavor(1, '1GB'), FakeFlavor(2, '2GB')]) self.m.StubOutWithMock(self.fc, 'instances') self.m.StubOutWithMock(self.fc.instances, 'create') users = [{"name": "testuser", "password": "pass", "host": "%", "databases": [{"name": "validdb"}]}] databases = [{"collate": "utf8_general_ci", "character_set": "utf8", "name": "validdb"}] self.fc.instances.create('test', 1, volume={'size': 30}, databases=databases, users=users, restorePoint=None, availability_zone=None ).AndReturn(fake_dbinstance) self.m.ReplayAll() def test_osdatabase_create(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_create', t) self._stubout_create(instance, fake_dbinstance) scheduler.TaskRunner(instance.create)() self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_osdatabase_create_overlimit(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_create', t) self._stubout_create(instance, fake_dbinstance) # Simulate an OverLimit exception self.m.StubOutWithMock(fake_dbinstance, 'get') fake_dbinstance.get().AndRaise( troveclient.exceptions.RequestEntityTooLarge) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_osdatabase_create_fails(self): fake_dbinstance = FakeDBInstance() fake_dbinstance.status = 'ERROR' t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_create', t) self._stubout_create(instance, fake_dbinstance) self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(instance.create)) self.m.VerifyAll() def test_osdatabase_delete(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_del', t) self._stubout_create(instance, fake_dbinstance) scheduler.TaskRunner(instance.create)() self.m.StubOutWithMock(self.fc.instances, 'get') self.fc.instances.get(12345).AndReturn(fake_dbinstance) self.m.StubOutWithMock(fake_dbinstance, 'delete') fake_dbinstance.delete().AndReturn(None) self.m.StubOutWithMock(fake_dbinstance, 'get') fake_dbinstance.get().AndReturn(None) fake_dbinstance.get().AndRaise(troveclient.exceptions.NotFound(404)) self.m.ReplayAll() scheduler.TaskRunner(instance.delete)() self.assertIsNone(instance.resource_id) self.m.VerifyAll() def test_osdatabase_delete_overlimit(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_del', t) self._stubout_create(instance, fake_dbinstance) scheduler.TaskRunner(instance.create)() self.m.StubOutWithMock(self.fc.instances, 'get') self.fc.instances.get(12345).AndReturn(fake_dbinstance) self.m.StubOutWithMock(fake_dbinstance, 'delete') fake_dbinstance.delete().AndReturn(None) # Simulate an OverLimit exception self.m.StubOutWithMock(fake_dbinstance, 'get') fake_dbinstance.get().AndRaise( troveclient.exceptions.RequestEntityTooLarge) fake_dbinstance.get().AndReturn(None) fake_dbinstance.get().AndRaise(troveclient.exceptions.NotFound(404)) self.m.ReplayAll() scheduler.TaskRunner(instance.delete)() self.assertIsNone(instance.resource_id) self.m.VerifyAll() def test_osdatabase_delete_resource_none(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_del', t) self._stubout_create(instance, fake_dbinstance) scheduler.TaskRunner(instance.create)() instance.resource_id = None self.m.ReplayAll() scheduler.TaskRunner(instance.delete)() self.assertIsNone(instance.resource_id) self.m.VerifyAll() def test_osdatabase_resource_not_found(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_del', t) self._stubout_create(instance, fake_dbinstance) scheduler.TaskRunner(instance.create)() self.m.StubOutWithMock(self.fc.instances, 'get') self.fc.instances.get(12345).AndRaise( troveclient.exceptions.NotFound(404)) self.m.ReplayAll() scheduler.TaskRunner(instance.delete)() self.assertIsNone(instance.resource_id) self.m.VerifyAll() def test_osdatabase_invalid_attribute(self): t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance("db_invalid_attrib", t) attrib = instance._resolve_attribute("invalid_attrib") self.assertIsNone(attrib) self.m.VerifyAll() def test_osdatabase_get_hostname(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_test', t) instance.resource_id = 12345 self.m.StubOutWithMock(instance, 'trove') instance.trove().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc, 'instances') self.m.StubOutWithMock(self.fc.instances, 'get') self.fc.instances.get(12345).AndReturn(fake_dbinstance) self.m.ReplayAll() attrib = instance._resolve_attribute('hostname') self.assertEqual(fake_dbinstance.hostname, attrib) self.m.VerifyAll() def test_osdatabase_get_href(self): fake_dbinstance = FakeDBInstance() t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_test', t) instance.resource_id = 12345 self.m.StubOutWithMock(instance, 'trove') instance.trove().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc, 'instances') self.m.StubOutWithMock(self.fc.instances, 'get') self.fc.instances.get(12345).AndReturn(fake_dbinstance) self.m.ReplayAll() attrib = instance._resolve_attribute('href') self.assertEqual(fake_dbinstance.links[0]['href'], attrib) def test_osdatabase_get_href_links_none(self): fake_dbinstance = FakeDBInstance() fake_dbinstance.links = None t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_test', t) instance.resource_id = 12345 self.m.StubOutWithMock(instance, 'trove') instance.trove().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc, 'instances') self.m.StubOutWithMock(self.fc.instances, 'get') self.fc.instances.get(12345).AndReturn(fake_dbinstance) self.m.ReplayAll() attrib = instance._resolve_attribute('href') self.assertIsNone(attrib) def test_osdatabase_prop_validation_success(self): t = template_format.parse(wp_template) instance = self._setup_test_clouddbinstance('dbinstance_test', t) ret = instance.validate() self.assertIsNone(ret) def test_osdatabase_prop_validation_invaliddb(self): t = template_format.parse(wp_template) t['Resources']['MySqlCloudDB']['Properties']['databases'] = [ {"name": "onedb"}] t['Resources']['MySqlCloudDB']['Properties']['users'] = [ {"name": "testuser", "password": "pass", "databases": ["invaliddb"]}] instance = self._setup_test_clouddbinstance('dbinstance_test', t) self.assertRaises(exception.StackValidationFailed, instance.validate) def test_osdatabase_prop_validation_users_none(self): t = template_format.parse(wp_template) t['Resources']['MySqlCloudDB']['Properties']['users'] = [] instance = self._setup_test_clouddbinstance('dbinstance_test', t) ret = instance.validate() self.assertIsNone(ret) def test_osdatabase_prop_validation_databases_none(self): t = template_format.parse(wp_template) t['Resources']['MySqlCloudDB']['Properties']['databases'] = [] t['Resources']['MySqlCloudDB']['Properties']['users'] = [ {"name": "testuser", "password": "pass", "databases": ["invaliddb"]}] instance = self._setup_test_clouddbinstance('dbinstance_test', t) self.assertRaises(exception.StackValidationFailed, instance.validate) def test_osdatabase_prop_validation_user_no_db(self): t = template_format.parse(wp_template) t['Resources']['MySqlCloudDB']['Properties']['databases'] = [ {"name": "validdb"}] t['Resources']['MySqlCloudDB']['Properties']['users'] = [ {"name": "testuser", "password": "pass", "databases": []}] instance = self._setup_test_clouddbinstance('dbinstance_test', t) self.assertRaises(exception.StackValidationFailed, instance.validate) heat-2014.1.5/heat/tests/test_environment.py0000664000567000056700000003654212540642614022103 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. import os.path import sys import fixtures import mock from oslo.config import cfg from heat.common import environment_format from heat.engine import environment from heat.engine import resources from heat.tests import common from heat.tests import generic_resource cfg.CONF.import_opt('environment_dir', 'heat.common.config') class EnvironmentTest(common.HeatTestCase): def setUp(self): super(EnvironmentTest, self).setUp() self.g_env = resources.global_env() def test_load_old_parameters(self): old = {u'a': u'ff', u'b': u'ss'} expected = {u'parameters': old, u'resource_registry': {u'resources': {}}} env = environment.Environment(old) self.assertEqual(expected, env.user_env_as_dict()) def test_load_new_env(self): new_env = {u'parameters': {u'a': u'ff', u'b': u'ss'}, u'resource_registry': {u'OS::Food': u'fruity.yaml', u'resources': {}}} env = environment.Environment(new_env) self.assertEqual(new_env, env.user_env_as_dict()) def test_global_registry(self): self.g_env.register_class('CloudX::Nova::Server', generic_resource.GenericResource) new_env = {u'parameters': {u'a': u'ff', u'b': u'ss'}, u'resource_registry': {u'OS::*': 'CloudX::*'}} env = environment.Environment(new_env) self.assertEqual('CloudX::Nova::Server', env.get_resource_info('OS::Nova::Server', 'my_db_server').name) def test_map_one_resource_type(self): new_env = {u'parameters': {u'a': u'ff', u'b': u'ss'}, u'resource_registry': {u'resources': {u'my_db_server': {u'OS::DBInstance': 'db.yaml'}}}} env = environment.Environment(new_env) info = env.get_resource_info('OS::DBInstance', 'my_db_server') self.assertEqual('db.yaml', info.value) def test_map_all_resources_of_type(self): self.g_env.register_class('OS::Nova::FloatingIP', generic_resource.GenericResource) new_env = {u'parameters': {u'a': u'ff', u'b': u'ss'}, u'resource_registry': {u'OS::Networking::FloatingIP': 'OS::Nova::FloatingIP', u'OS::Loadbalancer': 'lb.yaml'}} env = environment.Environment(new_env) self.assertEqual('OS::Nova::FloatingIP', env.get_resource_info('OS::Networking::FloatingIP', 'my_fip').name) def test_resource_sort_order_len(self): new_env = {u'resource_registry': {u'resources': {u'my_fip': { u'OS::Networking::FloatingIP': 'ip.yaml'}}}, u'OS::Networking::FloatingIP': 'OS::Nova::FloatingIP'} env = environment.Environment(new_env) self.assertEqual('ip.yaml', env.get_resource_info('OS::Networking::FloatingIP', 'my_fip').value) def test_env_load(self): new_env = {u'resource_registry': {u'resources': {u'my_fip': { u'OS::Networking::FloatingIP': 'ip.yaml'}}}} env = environment.Environment() self.assertIsNone(env.get_resource_info('OS::Networking::FloatingIP', 'my_fip')) env.load(new_env) self.assertEqual('ip.yaml', env.get_resource_info('OS::Networking::FloatingIP', 'my_fip').value) def test_constraints(self): env = environment.Environment({}) first_constraint = object() second_constraint = object() env.register_constraint("constraint1", first_constraint) env.register_constraint("constraint2", second_constraint) self.assertIs(first_constraint, env.get_constraint("constraint1")) self.assertIs(second_constraint, env.get_constraint("constraint2")) self.assertIs(None, env.get_constraint("no_constraint")) def test_constraints_registry(self): constraint_content = ''' class MyConstraint(object): pass def constraint_mapping(): return {"constraint1": MyConstraint} ''' plugin_dir = self.useFixture(fixtures.TempDir()) plugin_file = os.path.join(plugin_dir.path, 'test.py') with open(plugin_file, 'w+') as ef: ef.write(constraint_content) self.addCleanup(sys.modules.pop, "heat.engine.plugins.test") cfg.CONF.set_override('plugin_dirs', plugin_dir.path) env = environment.Environment({}) resources._load_global_environment(env) self.assertEqual("MyConstraint", env.get_constraint("constraint1").__name__) self.assertIs(None, env.get_constraint("no_constraint")) def test_constraints_registry_error(self): constraint_content = ''' def constraint_mapping(): raise ValueError("oops") ''' plugin_dir = self.useFixture(fixtures.TempDir()) plugin_file = os.path.join(plugin_dir.path, 'test.py') with open(plugin_file, 'w+') as ef: ef.write(constraint_content) self.addCleanup(sys.modules.pop, "heat.engine.plugins.test") cfg.CONF.set_override('plugin_dirs', plugin_dir.path) env = environment.Environment({}) error = self.assertRaises(ValueError, resources._load_global_environment, env) self.assertEqual("oops", str(error)) class EnvironmentDuplicateTest(common.HeatTestCase): scenarios = [ ('same', dict(resource_type='test.yaml', expected_equal=True)), ('diff_temp', dict(resource_type='not.yaml', expected_equal=False)), ('diff_map', dict(resource_type='OS::SomethingElse', expected_equal=False)), ('diff_path', dict(resource_type='a/test.yaml', expected_equal=False)), ] def test_env_load(self): env_initial = {u'resource_registry': { u'OS::Test::Dummy': 'test.yaml'}} env = environment.Environment() env.load(env_initial) info = env.get_resource_info('OS::Test::Dummy', 'something') replace_log = 'Changing %s from %s to %s' % ('OS::Test::Dummy', 'test.yaml', self.resource_type) self.assertNotIn(replace_log, self.logger.output) env_test = {u'resource_registry': { u'OS::Test::Dummy': self.resource_type}} env.load(env_test) if self.expected_equal: # should return exactly the same object. self.assertIs(info, env.get_resource_info('OS::Test::Dummy', 'my_fip')) self.assertNotIn(replace_log, self.logger.output) else: self.assertIn(replace_log, self.logger.output) self.assertNotEqual(info, env.get_resource_info('OS::Test::Dummy', 'my_fip')) class GlobalEnvLoadingTest(common.HeatTestCase): def test_happy_path(self): with mock.patch('glob.glob') as m_ldir: m_ldir.return_value = ['/etc_etc/heat/environment.d/a.yaml'] env_dir = '/etc_etc/heat/environment.d' env_content = '{"resource_registry": {}}' env = environment.Environment({}, user_env=False) with mock.patch('heat.engine.environment.open', mock.mock_open(read_data=env_content), create=True) as m_open: environment.read_global_environment(env, env_dir) m_ldir.assert_called_once_with(env_dir + '/*') m_open.assert_called_once_with('%s/a.yaml' % env_dir) def test_empty_env_dir(self): with mock.patch('glob.glob') as m_ldir: m_ldir.return_value = [] env_dir = '/etc_etc/heat/environment.d' env = environment.Environment({}, user_env=False) environment.read_global_environment(env, env_dir) m_ldir.assert_called_once_with(env_dir + '/*') def test_continue_on_ioerror(self): """assert we get all files processed even if there are processing exceptions. """ with mock.patch('glob.glob') as m_ldir: m_ldir.return_value = ['/etc_etc/heat/environment.d/a.yaml', '/etc_etc/heat/environment.d/b.yaml'] env_dir = '/etc_etc/heat/environment.d' env_content = '{}' env = environment.Environment({}, user_env=False) with mock.patch('heat.engine.environment.open', mock.mock_open(read_data=env_content), create=True) as m_open: m_open.side_effect = IOError environment.read_global_environment(env, env_dir) m_ldir.assert_called_once_with(env_dir + '/*') expected = [mock.call('%s/a.yaml' % env_dir), mock.call('%s/b.yaml' % env_dir)] self.assertEqual(expected, m_open.call_args_list) def test_continue_on_parse_error(self): """assert we get all files processed even if there are processing exceptions. """ with mock.patch('glob.glob') as m_ldir: m_ldir.return_value = ['/etc_etc/heat/environment.d/a.yaml', '/etc_etc/heat/environment.d/b.yaml'] env_dir = '/etc_etc/heat/environment.d' env_content = '{@$%#$%' env = environment.Environment({}, user_env=False) with mock.patch('heat.engine.environment.open', mock.mock_open(read_data=env_content), create=True) as m_open: environment.read_global_environment(env, env_dir) m_ldir.assert_called_once_with(env_dir + '/*') expected = [mock.call('%s/a.yaml' % env_dir), mock.call('%s/b.yaml' % env_dir)] self.assertEqual(expected, m_open.call_args_list) def test_env_resources_override_plugins(self): # assertion: any template resources in the global environment # should override the default plugins. # 1. set our own global test env # (with a template resource that shadows a plugin) g_env_content = ''' resource_registry: "OS::Nova::Server": "file:///not_really_here.yaml" ''' envdir = self.useFixture(fixtures.TempDir()) # envfile = os.path.join(envdir.path, 'test.yaml') with open(envfile, 'w+') as ef: ef.write(g_env_content) cfg.CONF.set_override('environment_dir', envdir.path) # 2. load global env g_env = environment.Environment({}, user_env=False) resources._load_global_environment(g_env) # 3. assert our resource is in place. self.assertEqual('file:///not_really_here.yaml', g_env.get_resource_info('OS::Nova::Server').value) def test_env_one_resource_disable(self): # prove we can disable a resource in the global environment g_env_content = ''' resource_registry: "OS::Nova::Server": ''' # 1. fake an environment file envdir = self.useFixture(fixtures.TempDir()) envfile = os.path.join(envdir.path, 'test.yaml') with open(envfile, 'w+') as ef: ef.write(g_env_content) cfg.CONF.set_override('environment_dir', envdir.path) # 2. load global env g_env = environment.Environment({}, user_env=False) resources._load_global_environment(g_env) # 3. assert our resource is in now gone. self.assertIsNone(g_env.get_resource_info('OS::Nova::Server')) # 4. make sure we haven't removed something we shouldn't have self.assertEqual(resources.instance.Instance, g_env.get_resource_info('AWS::EC2::Instance').value) def test_env_multi_resources_disable(self): # prove we can disable resources in the global environment g_env_content = ''' resource_registry: "AWS::*": ''' # 1. fake an environment file envdir = self.useFixture(fixtures.TempDir()) envfile = os.path.join(envdir.path, 'test.yaml') with open(envfile, 'w+') as ef: ef.write(g_env_content) cfg.CONF.set_override('environment_dir', envdir.path) # 2. load global env g_env = environment.Environment({}, user_env=False) resources._load_global_environment(g_env) # 3. assert our resources are now gone. self.assertIsNone(g_env.get_resource_info('AWS::EC2::Instance')) # 4. make sure we haven't removed something we shouldn't have self.assertEqual(resources.server.Server, g_env.get_resource_info('OS::Nova::Server').value) def test_env_user_cant_disable_sys_resource(self): # prove a user can't disable global resources from the user environment u_env_content = ''' resource_registry: "AWS::*": ''' # 1. load user env u_env = environment.Environment() u_env.load(environment_format.parse(u_env_content)) # 2. assert global resources are NOT gone. self.assertEqual( resources.instance.Instance, u_env.get_resource_info('AWS::EC2::Instance').value) def test_env_ignore_files_starting_dot(self): # prove we can disable a resource in the global environment g_env_content = '' # 1. fake an environment file envdir = self.useFixture(fixtures.TempDir()) with open(os.path.join(envdir.path, 'a.yaml'), 'w+') as ef: ef.write(g_env_content) with open(os.path.join(envdir.path, '.test.yaml'), 'w+') as ef: ef.write(g_env_content) with open(os.path.join(envdir.path, 'b.yaml'), 'w+') as ef: ef.write(g_env_content) cfg.CONF.set_override('environment_dir', envdir.path) # 2. load global env g_env = environment.Environment({}, user_env=False) with mock.patch('heat.engine.environment.open', mock.mock_open(read_data=g_env_content), create=True) as m_open: resources._load_global_environment(g_env) # 3. assert that the file were ignored expected = [mock.call('%s/a.yaml' % envdir.path), mock.call('%s/b.yaml' % envdir.path)] call_list = m_open.call_args_list expected.sort() call_list.sort() self.assertEqual(expected, call_list) heat-2014.1.5/heat/tests/test_neutron_vpnservice.py0000664000567000056700000007115112540642614023470 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. import copy from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.resources.neutron import vpnservice from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils neutronclient = try_import('neutronclient.v2_0.client') vpnservice_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test VPN service resource", "Parameters" : {}, "Resources" : { "VPNService" : { "Type" : "OS::Neutron::VPNService", "Properties" : { "name" : "VPNService", "description" : "My new VPN service", "admin_state_up" : true, "router_id" : "rou123", "subnet_id" : "sub123" } } } } ''' ipsec_site_connection_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test IPsec policy resource", "Parameters" : {}, "Resources" : { "IPsecSiteConnection" : { "Type" : "OS::Neutron::IPsecSiteConnection", "Properties" : { "name" : "IPsecSiteConnection", "description" : "My new VPN connection", "peer_address" : "172.24.4.233", "peer_id" : "172.24.4.233", "peer_cidrs" : [ "10.2.0.0/24" ], "mtu" : 1500, "dpd" : { "actions" : "hold", "interval" : 30, "timeout" : 120 }, "psk" : "secret", "initiator" : "bi-directional", "admin_state_up" : true, "ikepolicy_id" : "ike123", "ipsecpolicy_id" : "ips123", "vpnservice_id" : "vpn123" } } } } ''' ikepolicy_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test IKE policy resource", "Parameters" : {}, "Resources" : { "IKEPolicy" : { "Type" : "OS::Neutron::IKEPolicy", "Properties" : { "name" : "IKEPolicy", "description" : "My new IKE policy", "auth_algorithm" : "sha1", "encryption_algorithm" : "3des", "phase1_negotiation_mode" : "main", "lifetime" : { "units" : "seconds", "value" : 3600 }, "pfs" : "group5", "ike_version" : "v1" } } } } ''' ipsecpolicy_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test IPsec policy resource", "Parameters" : {}, "Resources" : { "IPsecPolicy" : { "Type" : "OS::Neutron::IPsecPolicy", "Properties" : { "name" : "IPsecPolicy", "description" : "My new IPsec policy", "transform_protocol": "esp", "encapsulation_mode" : "tunnel", "auth_algorithm" : "sha1", "encryption_algorithm" : "3des", "lifetime" : { "units" : "seconds", "value" : 3600 }, "pfs" : "group5" } } } } ''' @skipIf(neutronclient is None, 'neutronclient unavailable') class VPNServiceTest(HeatTestCase): VPN_SERVICE_CONF = { 'vpnservice': { 'name': 'VPNService', 'description': 'My new VPN service', 'admin_state_up': True, 'router_id': 'rou123', 'subnet_id': 'sub123' } } def setUp(self): super(VPNServiceTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_vpnservice') self.m.StubOutWithMock(neutronclient.Client, 'delete_vpnservice') self.m.StubOutWithMock(neutronclient.Client, 'show_vpnservice') self.m.StubOutWithMock(neutronclient.Client, 'update_vpnservice') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_vpnservice(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_vpnservice( self.VPN_SERVICE_CONF).AndReturn({'vpnservice': {'id': 'vpn123'}}) snippet = template_format.parse(vpnservice_template) self.stack = utils.parse_stack(snippet) return vpnservice.VPNService('vpnservice', snippet['Resources']['VPNService'], self.stack) @utils.stack_delete_after def test_create(self): rsrc = self.create_vpnservice() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_vpnservice(self.VPN_SERVICE_CONF).AndRaise( vpnservice.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(vpnservice_template) self.stack = utils.parse_stack(snippet) rsrc = vpnservice.VPNService('vpnservice', snippet['Resources']['VPNService'], self.stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete(self): neutronclient.Client.delete_vpnservice('vpn123') neutronclient.Client.show_vpnservice('vpn123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_vpnservice() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_already_gone(self): neutronclient.Client.delete_vpnservice('vpn123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_vpnservice() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_failed(self): neutronclient.Client.delete_vpnservice('vpn123').AndRaise( vpnservice.NeutronClientException(status_code=400)) rsrc = self.create_vpnservice() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_attribute(self): rsrc = self.create_vpnservice() neutronclient.Client.show_vpnservice('vpn123').MultipleTimes( ).AndReturn(self.VPN_SERVICE_CONF) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('VPNService', rsrc.FnGetAtt('name')) self.assertEqual('My new VPN service', rsrc.FnGetAtt('description')) self.assertIs(True, rsrc.FnGetAtt('admin_state_up')) self.assertEqual('rou123', rsrc.FnGetAtt('router_id')) self.assertEqual('sub123', rsrc.FnGetAtt('subnet_id')) self.m.VerifyAll() @utils.stack_delete_after def test_attribute_failed(self): rsrc = self.create_vpnservice() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'non-existent_property') self.assertEqual( 'The Referenced Attribute (vpnservice non-existent_property) is ' 'incorrect.', str(error)) self.m.VerifyAll() @utils.stack_delete_after def test_update(self): rsrc = self.create_vpnservice() neutronclient.Client.update_vpnservice( 'vpn123', {'vpnservice': {'admin_state_up': False}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['admin_state_up'] = False scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class IPsecSiteConnectionTest(HeatTestCase): IPSEC_SITE_CONNECTION_CONF = { 'ipsec_site_connection': { 'name': 'IPsecSiteConnection', 'description': 'My new VPN connection', 'peer_address': '172.24.4.233', 'peer_id': '172.24.4.233', 'peer_cidrs': ['10.2.0.0/24'], 'mtu': 1500, 'dpd': { 'actions': 'hold', 'interval': 30, 'timeout': 120 }, 'psk': 'secret', 'initiator': 'bi-directional', 'admin_state_up': True, 'ikepolicy_id': 'ike123', 'ipsecpolicy_id': 'ips123', 'vpnservice_id': 'vpn123' } } def setUp(self): super(IPsecSiteConnectionTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_ipsec_site_connection') self.m.StubOutWithMock(neutronclient.Client, 'delete_ipsec_site_connection') self.m.StubOutWithMock(neutronclient.Client, 'show_ipsec_site_connection') self.m.StubOutWithMock(neutronclient.Client, 'update_ipsec_site_connection') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_ipsec_site_connection(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_ipsec_site_connection( self.IPSEC_SITE_CONNECTION_CONF).AndReturn( {'ipsec_site_connection': {'id': 'con123'}}) snippet = template_format.parse(ipsec_site_connection_template) self.stack = utils.parse_stack(snippet) return vpnservice.IPsecSiteConnection( 'ipsec_site_connection', snippet['Resources']['IPsecSiteConnection'], self.stack) @utils.stack_delete_after def test_create(self): rsrc = self.create_ipsec_site_connection() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_ipsec_site_connection( self.IPSEC_SITE_CONNECTION_CONF).AndRaise( vpnservice.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(ipsec_site_connection_template) self.stack = utils.parse_stack(snippet) rsrc = vpnservice.IPsecSiteConnection( 'ipsec_site_connection', snippet['Resources']['IPsecSiteConnection'], self.stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete(self): neutronclient.Client.delete_ipsec_site_connection('con123') neutronclient.Client.show_ipsec_site_connection('con123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_ipsec_site_connection() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_already_gone(self): neutronclient.Client.delete_ipsec_site_connection('con123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_ipsec_site_connection() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_failed(self): neutronclient.Client.delete_ipsec_site_connection('con123').AndRaise( vpnservice.NeutronClientException(status_code=400)) rsrc = self.create_ipsec_site_connection() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_attribute(self): rsrc = self.create_ipsec_site_connection() neutronclient.Client.show_ipsec_site_connection( 'con123').MultipleTimes().AndReturn( self.IPSEC_SITE_CONNECTION_CONF) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('IPsecSiteConnection', rsrc.FnGetAtt('name')) self.assertEqual('My new VPN connection', rsrc.FnGetAtt('description')) self.assertEqual('172.24.4.233', rsrc.FnGetAtt('peer_address')) self.assertEqual('172.24.4.233', rsrc.FnGetAtt('peer_id')) self.assertEqual(['10.2.0.0/24'], rsrc.FnGetAtt('peer_cidrs')) self.assertEqual('hold', rsrc.FnGetAtt('dpd')['actions']) self.assertEqual(30, rsrc.FnGetAtt('dpd')['interval']) self.assertEqual(120, rsrc.FnGetAtt('dpd')['timeout']) self.assertEqual('secret', rsrc.FnGetAtt('psk')) self.assertEqual('bi-directional', rsrc.FnGetAtt('initiator')) self.assertIs(True, rsrc.FnGetAtt('admin_state_up')) self.assertEqual('ike123', rsrc.FnGetAtt('ikepolicy_id')) self.assertEqual('ips123', rsrc.FnGetAtt('ipsecpolicy_id')) self.assertEqual('vpn123', rsrc.FnGetAtt('vpnservice_id')) self.m.VerifyAll() @utils.stack_delete_after def test_attribute_failed(self): rsrc = self.create_ipsec_site_connection() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'non-existent_property') self.assertEqual( 'The Referenced Attribute (ipsec_site_connection ' 'non-existent_property) is incorrect.', str(error)) self.m.VerifyAll() @utils.stack_delete_after def test_update(self): rsrc = self.create_ipsec_site_connection() neutronclient.Client.update_ipsec_site_connection( 'con123', {'ipsec_site_connection': {'admin_state_up': False}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['admin_state_up'] = False scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class IKEPolicyTest(HeatTestCase): IKE_POLICY_CONF = { 'ikepolicy': { 'name': 'IKEPolicy', 'description': 'My new IKE policy', 'auth_algorithm': 'sha1', 'encryption_algorithm': '3des', 'phase1_negotiation_mode': 'main', 'lifetime': { 'units': 'seconds', 'value': 3600 }, 'pfs': 'group5', 'ike_version': 'v1' } } def setUp(self): super(IKEPolicyTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_ikepolicy') self.m.StubOutWithMock(neutronclient.Client, 'delete_ikepolicy') self.m.StubOutWithMock(neutronclient.Client, 'show_ikepolicy') self.m.StubOutWithMock(neutronclient.Client, 'update_ikepolicy') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_ikepolicy(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_ikepolicy( self.IKE_POLICY_CONF).AndReturn( {'ikepolicy': {'id': 'ike123'}}) snippet = template_format.parse(ikepolicy_template) self.stack = utils.parse_stack(snippet) return vpnservice.IKEPolicy('ikepolicy', snippet['Resources']['IKEPolicy'], self.stack) @utils.stack_delete_after def test_create(self): rsrc = self.create_ikepolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_ikepolicy( self.IKE_POLICY_CONF).AndRaise( vpnservice.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(ikepolicy_template) self.stack = utils.parse_stack(snippet) rsrc = vpnservice.IKEPolicy( 'ikepolicy', snippet['Resources']['IKEPolicy'], self.stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete(self): neutronclient.Client.delete_ikepolicy('ike123') neutronclient.Client.show_ikepolicy('ike123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_ikepolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_already_gone(self): neutronclient.Client.delete_ikepolicy('ike123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_ikepolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_failed(self): neutronclient.Client.delete_ikepolicy('ike123').AndRaise( vpnservice.NeutronClientException(status_code=400)) rsrc = self.create_ikepolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_attribute(self): rsrc = self.create_ikepolicy() neutronclient.Client.show_ikepolicy( 'ike123').MultipleTimes().AndReturn(self.IKE_POLICY_CONF) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('IKEPolicy', rsrc.FnGetAtt('name')) self.assertEqual('My new IKE policy', rsrc.FnGetAtt('description')) self.assertEqual('sha1', rsrc.FnGetAtt('auth_algorithm')) self.assertEqual('3des', rsrc.FnGetAtt('encryption_algorithm')) self.assertEqual('main', rsrc.FnGetAtt('phase1_negotiation_mode')) self.assertEqual('seconds', rsrc.FnGetAtt('lifetime')['units']) self.assertEqual(3600, rsrc.FnGetAtt('lifetime')['value']) self.assertEqual('group5', rsrc.FnGetAtt('pfs')) self.assertEqual('v1', rsrc.FnGetAtt('ike_version')) self.m.VerifyAll() @utils.stack_delete_after def test_attribute_failed(self): rsrc = self.create_ikepolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'non-existent_property') self.assertEqual( 'The Referenced Attribute (ikepolicy non-existent_property) is ' 'incorrect.', str(error)) self.m.VerifyAll() @utils.stack_delete_after def test_update(self): rsrc = self.create_ikepolicy() neutronclient.Client.update_ikepolicy('ike123', {'ikepolicy': { 'name': 'New IKEPolicy'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['name'] = 'New IKEPolicy' scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class IPsecPolicyTest(HeatTestCase): IPSEC_POLICY_CONF = { 'ipsecpolicy': { 'name': 'IPsecPolicy', 'description': 'My new IPsec policy', 'transform_protocol': 'esp', 'encapsulation_mode': 'tunnel', 'auth_algorithm': 'sha1', 'encryption_algorithm': '3des', 'lifetime': { 'units': 'seconds', 'value': 3600 }, 'pfs': 'group5' } } def setUp(self): super(IPsecPolicyTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_ipsecpolicy') self.m.StubOutWithMock(neutronclient.Client, 'delete_ipsecpolicy') self.m.StubOutWithMock(neutronclient.Client, 'show_ipsecpolicy') self.m.StubOutWithMock(neutronclient.Client, 'update_ipsecpolicy') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_ipsecpolicy(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_ipsecpolicy( self.IPSEC_POLICY_CONF).AndReturn( {'ipsecpolicy': {'id': 'ips123'}}) snippet = template_format.parse(ipsecpolicy_template) self.stack = utils.parse_stack(snippet) return vpnservice.IPsecPolicy('ipsecpolicy', snippet['Resources']['IPsecPolicy'], self.stack) @utils.stack_delete_after def test_create(self): rsrc = self.create_ipsecpolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_ipsecpolicy( self.IPSEC_POLICY_CONF).AndRaise( vpnservice.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(ipsecpolicy_template) self.stack = utils.parse_stack(snippet) rsrc = vpnservice.IPsecPolicy( 'ipsecpolicy', snippet['Resources']['IPsecPolicy'], self.stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete(self): neutronclient.Client.delete_ipsecpolicy('ips123') neutronclient.Client.show_ipsecpolicy('ips123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_ipsecpolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_already_gone(self): neutronclient.Client.delete_ipsecpolicy('ips123').AndRaise( vpnservice.NeutronClientException(status_code=404)) rsrc = self.create_ipsecpolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_delete_failed(self): neutronclient.Client.delete_ipsecpolicy('ips123').AndRaise( vpnservice.NeutronClientException(status_code=400)) rsrc = self.create_ipsecpolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_attribute(self): rsrc = self.create_ipsecpolicy() neutronclient.Client.show_ipsecpolicy( 'ips123').MultipleTimes().AndReturn(self.IPSEC_POLICY_CONF) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('IPsecPolicy', rsrc.FnGetAtt('name')) self.assertEqual('My new IPsec policy', rsrc.FnGetAtt('description')) self.assertEqual('esp', rsrc.FnGetAtt('transform_protocol')) self.assertEqual('tunnel', rsrc.FnGetAtt('encapsulation_mode')) self.assertEqual('sha1', rsrc.FnGetAtt('auth_algorithm')) self.assertEqual('3des', rsrc.FnGetAtt('encryption_algorithm')) self.assertEqual('seconds', rsrc.FnGetAtt('lifetime')['units']) self.assertEqual(3600, rsrc.FnGetAtt('lifetime')['value']) self.assertEqual('group5', rsrc.FnGetAtt('pfs')) self.m.VerifyAll() @utils.stack_delete_after def test_attribute_failed(self): rsrc = self.create_ipsecpolicy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'non-existent_property') self.assertEqual( 'The Referenced Attribute (ipsecpolicy non-existent_property) is ' 'incorrect.', str(error)) self.m.VerifyAll() @utils.stack_delete_after def test_update(self): rsrc = self.create_ipsecpolicy() neutronclient.Client.update_ipsecpolicy( 'ips123', {'ipsecpolicy': {'name': 'New IPsecPolicy'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['name'] = 'New IPsecPolicy' scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_common_context.py0000664000567000056700000002044312540642614022564 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. import mock import os from oslo.config import cfg import webob from heat.common import context from heat.common import exception from heat.openstack.common import policy as base_policy from heat.tests.common import HeatTestCase policy_path = os.path.dirname(os.path.realpath(__file__)) + "/policy/" class TestRequestContext(HeatTestCase): def setUp(self): self.ctx = {'username': 'mick', 'trustor_user_id': None, 'auth_token': '123', 'is_admin': False, 'user': 'mick', 'password': 'foo', 'trust_id': None, 'show_deleted': False, 'roles': ['arole', 'notadmin'], 'tenant_id': '456tenant', 'user_id': 'fooUser', 'tenant': 'atenant', 'auth_url': 'http://xyz', 'aws_creds': 'blah'} super(TestRequestContext, self).setUp() def test_request_context_init(self): ctx = context.RequestContext(auth_token=self.ctx.get('auth_token'), username=self.ctx.get('username'), password=self.ctx.get('password'), aws_creds=self.ctx.get('aws_creds'), tenant=self.ctx.get('tenant'), tenant_id=self.ctx.get('tenant_id'), user_id=self.ctx.get('user_id'), auth_url=self.ctx.get('auth_url'), roles=self.ctx.get('roles'), show_deleted=self.ctx.get('show_deleted'), is_admin=self.ctx.get('is_admin')) ctx_dict = ctx.to_dict() del(ctx_dict['request_id']) self.assertEqual(self.ctx, ctx_dict) def test_request_context_from_dict(self): ctx = context.RequestContext.from_dict(self.ctx) ctx_dict = ctx.to_dict() del(ctx_dict['request_id']) self.assertEqual(self.ctx, ctx_dict) def test_request_context_update(self): ctx = context.RequestContext.from_dict(self.ctx) for k in self.ctx: self.assertEqual(self.ctx.get(k), ctx.to_dict().get(k)) override = '%s_override' % k setattr(ctx, k, override) self.assertEqual(override, ctx.to_dict().get(k)) def test_get_admin_context(self): ctx = context.get_admin_context() self.assertTrue(ctx.is_admin) self.assertFalse(ctx.show_deleted) def test_get_admin_context_show_deleted(self): ctx = context.get_admin_context(show_deleted=True) self.assertTrue(ctx.is_admin) self.assertTrue(ctx.show_deleted) def test_admin_context_policy_true(self): policy_check = 'heat.common.policy.Enforcer.check_is_admin' with mock.patch(policy_check) as pc: pc.return_value = True ctx = context.RequestContext(roles=['admin']) self.assertTrue(ctx.is_admin) def test_admin_context_policy_false(self): policy_check = 'heat.common.policy.Enforcer.check_is_admin' with mock.patch(policy_check) as pc: pc.return_value = False ctx = context.RequestContext(roles=['notadmin']) self.assertFalse(ctx.is_admin) class RequestContextMiddlewareTest(HeatTestCase): scenarios = [( 'empty_headers', dict( headers={}, expected_exception=None, context_dict={ 'auth_token': None, 'auth_url': None, 'aws_creds': None, 'is_admin': False, 'password': None, 'roles': [], 'show_deleted': False, 'tenant': None, 'tenant_id': None, 'trust_id': None, 'trustor_user_id': None, 'user': None, 'user_id': None, 'username': None }) ), ( 'username_password', dict( headers={ 'X-Auth-User': 'my_username', 'X-Auth-Key': 'my_password', 'X-Auth-EC2-Creds': '{"ec2Credentials": {}}', 'X-User-Id': '7a87ff18-31c6-45ce-a186-ec7987f488c3', 'X-Auth-Token': 'atoken', 'X-Tenant-Name': 'my_tenant', 'X-Tenant-Id': 'db6808c8-62d0-4d92-898c-d644a6af20e9', 'X-Auth-Url': 'http://192.0.2.1:5000/v1', 'X-Roles': 'role1,role2,role3' }, expected_exception=None, context_dict={ 'auth_token': 'atoken', 'auth_url': 'http://192.0.2.1:5000/v1', 'aws_creds': None, 'is_admin': False, 'password': 'my_password', 'roles': ['role1', 'role2', 'role3'], 'show_deleted': False, 'tenant': 'my_tenant', 'tenant_id': 'db6808c8-62d0-4d92-898c-d644a6af20e9', 'trust_id': None, 'trustor_user_id': None, 'user': 'my_username', 'user_id': '7a87ff18-31c6-45ce-a186-ec7987f488c3', 'username': 'my_username' }) ), ( 'aws_creds', dict( headers={ 'X-Auth-EC2-Creds': '{"ec2Credentials": {}}', 'X-User-Id': '7a87ff18-31c6-45ce-a186-ec7987f488c3', 'X-Auth-Token': 'atoken', 'X-Tenant-Name': 'my_tenant', 'X-Tenant-Id': 'db6808c8-62d0-4d92-898c-d644a6af20e9', 'X-Auth-Url': 'http://192.0.2.1:5000/v1', 'X-Roles': 'role1,role2,role3', }, expected_exception=None, context_dict={ 'auth_token': 'atoken', 'auth_url': 'http://192.0.2.1:5000/v1', 'aws_creds': '{"ec2Credentials": {}}', 'is_admin': False, 'password': None, 'roles': ['role1', 'role2', 'role3'], 'show_deleted': False, 'tenant': 'my_tenant', 'tenant_id': 'db6808c8-62d0-4d92-898c-d644a6af20e9', 'trust_id': None, 'trustor_user_id': None, 'user': None, 'user_id': '7a87ff18-31c6-45ce-a186-ec7987f488c3', 'username': None }) ), ( 'malformed_roles', dict( headers={ 'X-Roles': [], }, expected_exception=exception.NotAuthenticated) )] def setUp(self): super(RequestContextMiddlewareTest, self).setUp() opts = [ cfg.StrOpt('config_dir', default=policy_path), cfg.StrOpt('config_file', default='foo'), cfg.StrOpt('project', default='heat'), ] cfg.CONF.register_opts(opts) pf = policy_path + 'check_admin.json' self.m.StubOutWithMock(base_policy.Enforcer, '_get_policy_path') base_policy.Enforcer._get_policy_path().MultipleTimes().AndReturn(pf) self.m.ReplayAll() def test_context_middleware(self): middleware = context.ContextMiddleware(None, None) request = webob.Request.blank('/stacks', headers=self.headers) if self.expected_exception: self.assertRaises( self.expected_exception, middleware.process_request, request) else: self.assertIsNone(middleware.process_request(request)) ctx = request.context.to_dict() for k, v in self.context_dict.items(): self.assertEqual(v, ctx[k], 'Key %s values do not match' % k) heat-2014.1.5/heat/tests/test_event.py0000664000567000056700000001400012540642614020641 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. from oslo.config import cfg from heat.db import api as db_api from heat.engine import event from heat.engine import parser from heat.engine import resource from heat.engine import template from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import utils cfg.CONF.import_opt('event_purge_batch_size', 'heat.common.config') cfg.CONF.import_opt('max_events_per_stack', 'heat.common.config') tmpl = { 'Resources': { 'EventTestResource': { 'Type': 'ResourceWithRequiredProps', 'Properties': {'Foo': 'goo'} } } } class EventTest(HeatTestCase): def setUp(self): super(EventTest, self).setUp() self.username = 'event_test_user' utils.setup_dummy_db() self.ctx = utils.dummy_context() self.m.ReplayAll() resource._register_class('ResourceWithRequiredProps', generic_rsrc.ResourceWithRequiredProps) self.stack = parser.Stack(self.ctx, 'event_load_test_stack', template.Template(tmpl)) self.stack.store() self.resource = self.stack['EventTestResource'] self.resource._store() self.addCleanup(db_api.stack_delete, self.ctx, self.stack.id) def test_load(self): self.resource.resource_id_set('resource_physical_id') e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'wibble', self.resource.properties, self.resource.name, self.resource.type()) e.store() self.assertIsNotNone(e.id) loaded_e = event.Event.load(self.ctx, e.id) self.assertEqual(self.stack.id, loaded_e.stack.id) self.assertEqual(self.resource.name, loaded_e.resource_name) self.assertEqual('wibble', loaded_e.physical_resource_id) self.assertEqual('TEST', loaded_e.action) self.assertEqual('IN_PROGRESS', loaded_e.status) self.assertEqual('Testing', loaded_e.reason) self.assertIsNotNone(loaded_e.timestamp) self.assertEqual({'Foo': 'goo'}, loaded_e.resource_properties) def test_load_given_stack_event(self): self.resource.resource_id_set('resource_physical_id') e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'wibble', self.resource.properties, self.resource.name, self.resource.type()) e.store() self.assertIsNotNone(e.id) ev = db_api.event_get(self.ctx, e.id) loaded_e = event.Event.load(self.ctx, e.id, stack=self.stack, event=ev) self.assertEqual(self.stack.id, loaded_e.stack.id) self.assertEqual(self.resource.name, loaded_e.resource_name) self.assertEqual('wibble', loaded_e.physical_resource_id) self.assertEqual('TEST', loaded_e.action) self.assertEqual('IN_PROGRESS', loaded_e.status) self.assertEqual('Testing', loaded_e.reason) self.assertIsNotNone(loaded_e.timestamp) self.assertEqual({'Foo': 'goo'}, loaded_e.resource_properties) def test_store_caps_events(self): cfg.CONF.set_override('event_purge_batch_size', 1) cfg.CONF.set_override('max_events_per_stack', 1) self.resource.resource_id_set('resource_physical_id') e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'alabama', self.resource.properties, self.resource.name, self.resource.type()) e.store() self.assertEqual(1, len(db_api.event_get_all_by_stack(self.ctx, self.stack.id))) e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'arizona', self.resource.properties, self.resource.name, self.resource.type()) e.store() events = db_api.event_get_all_by_stack(self.ctx, self.stack.id) self.assertEqual(1, len(events)) self.assertEqual('arizona', events[0].physical_resource_id) def test_identifier(self): event_uuid = 'abc123yc-9f88-404d-a85b-531529456xyz' e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'wibble', self.resource.properties, self.resource.name, self.resource.type(), uuid=event_uuid) e.store() expected_identifier = { 'stack_name': self.stack.name, 'stack_id': self.stack.id, 'tenant': self.ctx.tenant_id, 'path': '/resources/EventTestResource/events/%s' % str(event_uuid) } self.assertEqual(expected_identifier, e.identifier()) def test_identifier_is_none(self): e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'wibble', self.resource.properties, self.resource.name, self.resource.type()) e.store() self.assertIsNone(e.identifier()) def test_badprop(self): tmpl = {'Type': 'ResourceWithRequiredProps', 'Properties': {'Foo': False}} rname = 'bad_resource' res = generic_rsrc.ResourceWithRequiredProps(rname, tmpl, self.stack) e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing', 'wibble', res.properties, res.name, res.type()) self.assertIn('Error', e.resource_properties) heat-2014.1.5/heat/tests/test_urlfetch.py0000664000567000056700000001010712540642614021340 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. from oslo.config import cfg import requests from requests import exceptions from six.moves import cStringIO from heat.common import urlfetch from heat.openstack.common.py3kcompat import urlutils from heat.tests.common import HeatTestCase class Response: def __init__(self, buf=''): self.buf = buf def iter_content(self, chunk_size=1): while self.buf: yield self.buf[:chunk_size] self.buf = self.buf[chunk_size:] def raise_for_status(self): pass class UrlFetchTest(HeatTestCase): def setUp(self): super(UrlFetchTest, self).setUp() self.m.StubOutWithMock(requests, 'get') def test_file_scheme_default_behaviour(self): self.m.ReplayAll() self.assertRaises(IOError, urlfetch.get, 'file:///etc/profile') self.m.VerifyAll() def test_file_scheme_supported(self): data = '{ "foo": "bar" }' url = 'file:///etc/profile' self.m.StubOutWithMock(urlutils, 'urlopen') urlutils.urlopen(url).AndReturn(cStringIO(data)) self.m.ReplayAll() self.assertEqual(data, urlfetch.get(url, allowed_schemes=['file'])) self.m.VerifyAll() def test_file_scheme_failure(self): url = 'file:///etc/profile' self.m.StubOutWithMock(urlutils, 'urlopen') urlutils.urlopen(url).AndRaise(urlutils.URLError('oops')) self.m.ReplayAll() self.assertRaises(IOError, urlfetch.get, url, allowed_schemes=['file']) self.m.VerifyAll() def test_http_scheme(self): url = 'http://example.com/template' data = '{ "foo": "bar" }' response = Response(data) requests.get(url, stream=True).AndReturn(response) self.m.ReplayAll() self.assertEqual(data, urlfetch.get(url)) self.m.VerifyAll() def test_https_scheme(self): url = 'https://example.com/template' data = '{ "foo": "bar" }' response = Response(data) requests.get(url, stream=True).AndReturn(response) self.m.ReplayAll() self.assertEqual(data, urlfetch.get(url)) self.m.VerifyAll() def test_http_error(self): url = 'http://example.com/template' requests.get(url, stream=True).AndRaise(exceptions.HTTPError()) self.m.ReplayAll() self.assertRaises(IOError, urlfetch.get, url) self.m.VerifyAll() def test_non_exist_url(self): url = 'http://non-exist.com/template' requests.get(url, stream=True).AndRaise(exceptions.Timeout()) self.m.ReplayAll() self.assertRaises(IOError, urlfetch.get, url) self.m.VerifyAll() def test_garbage(self): self.m.ReplayAll() self.assertRaises(IOError, urlfetch.get, 'wibble') self.m.VerifyAll() def test_max_fetch_size_okay(self): url = 'http://example.com/template' data = '{ "foo": "bar" }' response = Response(data) cfg.CONF.set_override('max_template_size', 500) requests.get(url, stream=True).AndReturn(response) self.m.ReplayAll() urlfetch.get(url) self.m.VerifyAll() def test_max_fetch_size_error(self): url = 'http://example.com/template' data = '{ "foo": "bar" }' response = Response(data) cfg.CONF.set_override('max_template_size', 5) requests.get(url, stream=True).AndReturn(response) self.m.ReplayAll() exception = self.assertRaises(IOError, urlfetch.get, url) self.assertIn("Template exceeds", str(exception)) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_instance_group.py0000664000567000056700000003124312540642614022550 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. import copy import mox from heat.common import exception from heat.common import template_format from heat.engine import parser from heat.engine import resource from heat.engine import resources from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import nova_keypair from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import utils ig_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create multiple instances.", "Parameters" : {}, "Resources" : { "JobServerGroup" : { "Type" : "OS::Heat::InstanceGroup", "Properties" : { "LaunchConfigurationName" : { "Ref" : "JobServerConfig" }, "Size" : "1", "AvailabilityZones" : ["nova"] } }, "JobServerConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.large", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' class InstanceGroupTest(HeatTestCase): def setUp(self): super(InstanceGroupTest, self).setUp() utils.setup_dummy_db() def _stub_create(self, num, instance_class=instance.Instance): """ Expect creation of C{num} number of Instances. :param instance_class: The resource class to expect to be created instead of instance.Instance. """ self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(instance_class, 'handle_create') self.m.StubOutWithMock(instance_class, 'check_create_complete') cookie = object() for x in range(num): instance_class.handle_create().AndReturn(cookie) instance_class.check_create_complete(cookie).AndReturn(False) instance_class.check_create_complete( cookie).MultipleTimes().AndReturn(True) def create_resource(self, t, stack, resource_name): # subsequent resources may need to reference previous created resources # use the stack's resource objects instead of instantiating new ones rsrc = stack[resource_name] self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_instance_group(self): t = template_format.parse(ig_template) stack = utils.parse_stack(t) # start with min then delete self._stub_create(1) self.m.StubOutWithMock(instance.Instance, 'FnGetAtt') instance.Instance.FnGetAtt('PublicIp').AndReturn('1.2.3.4') self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual('1.2.3.4', rsrc.FnGetAtt('InstanceList')) nested = rsrc.nested() self.assertEqual(nested.id, rsrc.resource_id) rsrc.delete() self.m.VerifyAll() def test_instance_group_custom_resource(self): """ If AWS::EC2::Instance is overridden, InstanceGroup will automatically use that overridden resource type. """ # resources may need to be initialised if this is the first test run. resources.initialise() class MyInstance(instance.Instance): """A customized Instance resource.""" original_instance = resource.get_class("AWS::EC2::Instance") resource._register_class("AWS::EC2::Instance", MyInstance) self.addCleanup(resource._register_class, "AWS::EC2::Instance", original_instance) t = template_format.parse(ig_template) stack = utils.parse_stack(t) self._stub_create(1, instance_class=MyInstance) self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) rsrc.delete() self.m.VerifyAll() def test_missing_image(self): t = template_format.parse(ig_template) stack = utils.parse_stack(t) self.create_resource(t, stack, 'JobServerConfig') rsrc = stack['JobServerGroup'] self.m.StubOutWithMock(instance.Instance, 'handle_create') not_found = exception.ImageNotFound(image_name='bla') instance.Instance.handle_create().AndRaise(not_found) self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_handle_update_size(self): t = template_format.parse(ig_template) properties = t['Resources']['JobServerGroup']['Properties'] properties['Size'] = '2' stack = utils.parse_stack(t) self._stub_create(2) self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.m.VerifyAll() self.m.UnsetStubs() # Increase min size to 5 self._stub_create(3) self.m.StubOutWithMock(instance.Instance, 'FnGetAtt') instance.Instance.FnGetAtt('PublicIp').AndReturn('10.0.0.2') instance.Instance.FnGetAtt('PublicIp').AndReturn('10.0.0.3') instance.Instance.FnGetAtt('PublicIp').AndReturn('10.0.0.4') instance.Instance.FnGetAtt('PublicIp').AndReturn('10.0.0.5') instance.Instance.FnGetAtt('PublicIp').AndReturn('10.0.0.6') self.m.ReplayAll() update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['Size'] = '5' tmpl_diff = {'Properties': {'Size': '5'}} prop_diff = {'Size': '5'} self.assertIsNone(rsrc.handle_update(update_snippet, tmpl_diff, prop_diff)) self.assertEqual('10.0.0.2,10.0.0.3,10.0.0.4,10.0.0.5,10.0.0.6', rsrc.FnGetAtt('InstanceList')) rsrc.delete() self.m.VerifyAll() def test_create_error(self): """ If a resource in an instance group fails to be created, the instance group itself will fail and the broken inner resource will remain. """ t = template_format.parse(ig_template) stack = utils.parse_stack(t) self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(instance.Instance, 'handle_create') instance.Instance.handle_create().AndRaise(Exception) self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') self.assertRaises( exception.ResourceFailure, self.create_resource, t, stack, 'JobServerGroup') rsrc = stack['JobServerGroup'] self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) # The failed inner resource remains self.assertEqual(1, len(rsrc.nested().resources)) child_resource = rsrc.nested().resources.values()[0] self.assertEqual((child_resource.CREATE, child_resource.FAILED), child_resource.state) self.m.VerifyAll() def test_update_error(self): """ If a resource in an instance group fails to be created during an update, the instance group itself will fail and the broken inner resource will remain. """ t = template_format.parse(ig_template) stack = utils.parse_stack(t) self._stub_create(1) self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.assertEqual(1, len(rsrc.nested().resources)) succeeded_instance = rsrc.nested().resources.values()[0] self.m.VerifyAll() self.m.UnsetStubs() self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(instance.Instance, 'handle_create') instance.Instance.handle_create().AndRaise(Exception) self.m.ReplayAll() update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['Size'] = '2' updater = scheduler.TaskRunner(rsrc.update, update_snippet) self.assertRaises(exception.ResourceFailure, updater) self.assertEqual((rsrc.UPDATE, rsrc.FAILED), rsrc.state) # The failed inner resource remains self.assertEqual(2, len(rsrc.nested().resources)) child_resource = [r for r in rsrc.nested().resources.values() if r.name != succeeded_instance.name][0] self.assertEqual((child_resource.CREATE, child_resource.FAILED), child_resource.state) self.m.VerifyAll() def test_update_fail_badkey(self): t = template_format.parse(ig_template) properties = t['Resources']['JobServerGroup']['Properties'] properties['Size'] = '2' stack = utils.parse_stack(t) self._stub_create(2) self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.m.ReplayAll() update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Metadata'] = 'notallowedforupdate' updater = scheduler.TaskRunner(rsrc.update, update_snippet) self.assertRaises(resource.UpdateReplace, updater) rsrc.delete() self.m.VerifyAll() def test_update_fail_badprop(self): t = template_format.parse(ig_template) properties = t['Resources']['JobServerGroup']['Properties'] properties['Size'] = '2' stack = utils.parse_stack(t) self._stub_create(2) self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.m.ReplayAll() update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['AvailabilityZones'] = ['wibble'] updater = scheduler.TaskRunner(rsrc.update, update_snippet) self.assertRaises(resource.UpdateReplace, updater) rsrc.delete() self.m.VerifyAll() heat-2014.1.5/heat/tests/templates/0000775000567000056700000000000012540643116020110 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/templates/Neutron.yaml0000664000567000056700000000351312540642611022427 0ustar jenkinsjenkins00000000000000HeatTemplateFormatVersion: '2012-12-12' Description: Template to test Neutron resources Resources: network: Type: OS::Neutron::Net Properties: {name: the_network} unnamed_network: Type: 'OS::Neutron::Net' admin_down_network: Type: OS::Neutron::Net Properties: {admin_state_up: false} subnet: Type: OS::Neutron::Subnet Properties: network_id: {Ref: network} ip_version: 4 cidr: 10.0.3.0/24 allocation_pools: - {end: 10.0.3.150, start: 10.0.3.20} port: Type: OS::Neutron::Port Properties: device_id: d6b4d3a5-c700-476f-b609-1493dd9dadc0 name: port1 network_id: {Ref: network} fixed_ips: - subnet_id: {Ref: subnet} ip_address: 10.0.3.21 router: Type: 'OS::Neutron::Router' router_interface: Type: OS::Neutron::RouterInterface Properties: router_id: {Ref: router} subnet_id: {Ref: subnet} Outputs: the_network_status: Value: Fn::GetAtt: [network, status] Description: Status of network port_device_owner: Value: Fn::GetAtt: [port, device_owner] Description: Device owner of the port port_fixed_ips: Value: Fn::GetAtt: [port, fixed_ips] Description: Fixed IPs of the port port_mac_address: Value: Fn::GetAtt: [port, mac_address] Description: MAC address of the port port_status: Value: Fn::GetAtt: [port, status] Description: Status of the port port_show: Value: Fn::GetAtt: [port, show] Description: All attributes for port subnet_show: Value: Fn::GetAtt: [subnet, show] Description: All attributes for subnet network_show: Value: Fn::GetAtt: [network, show] Description: All attributes for network router_show: Value: Fn::GetAtt: [router, show] Description: All attributes for router heat-2014.1.5/heat/tests/templates/Neutron.template0000664000567000056700000000476112540642611023306 0ustar jenkinsjenkins00000000000000{ "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test Neutron resources", "Resources" : { "network": { "Type": "OS::Neutron::Net", "Properties": { "name": "the_network" } }, "unnamed_network": { "Type": "OS::Neutron::Net" }, "admin_down_network": { "Type": "OS::Neutron::Net", "Properties": { "admin_state_up": false } }, "subnet": { "Type": "OS::Neutron::Subnet", "Properties": { "network_id": { "Ref" : "network" }, "ip_version": 4, "cidr": "10.0.3.0/24", "allocation_pools": [{"start": "10.0.3.20", "end": "10.0.3.150"}] } }, "port": { "Type": "OS::Neutron::Port", "Properties": { "device_id": "d6b4d3a5-c700-476f-b609-1493dd9dadc0", "name": "port1", "network_id": { "Ref" : "network" }, "fixed_ips": [{ "subnet_id": { "Ref" : "subnet" }, "ip_address": "10.0.3.21" }] } }, "router": { "Type": "OS::Neutron::Router" }, "router_interface": { "Type": "OS::Neutron::RouterInterface", "Properties": { "router_id": { "Ref" : "router" }, "subnet_id": { "Ref" : "subnet" } } } }, "Outputs" : { "the_network_status" : { "Value" : { "Fn::GetAtt" : [ "network", "status" ]}, "Description" : "Status of network" }, "port_device_owner" : { "Value" : { "Fn::GetAtt" : [ "port", "device_owner" ]}, "Description" : "Device owner of the port" }, "port_fixed_ips" : { "Value" : { "Fn::GetAtt" : [ "port", "fixed_ips" ]}, "Description" : "Fixed IPs of the port" }, "port_mac_address" : { "Value" : { "Fn::GetAtt" : [ "port", "mac_address" ]}, "Description" : "MAC address of the port" }, "port_status" : { "Value" : { "Fn::GetAtt" : [ "port", "status" ]}, "Description" : "Status of the port" }, "port_show" : { "Value" : { "Fn::GetAtt" : [ "port", "show" ]}, "Description" : "All attributes for port" }, "subnet_show" : { "Value" : { "Fn::GetAtt" : [ "subnet", "show" ]}, "Description" : "All attributes for subnet" }, "network_show" : { "Value" : { "Fn::GetAtt" : [ "network", "show" ]}, "Description" : "All attributes for network" }, "router_show" : { "Value" : { "Fn::GetAtt" : [ "router", "show" ]}, "Description" : "All attributes for router" } } } heat-2014.1.5/heat/tests/templates/WordPress_Single_Instance.yaml0000664000567000056700000001204712540642611026054 0ustar jenkinsjenkins00000000000000HeatTemplateFormatVersion: '2012-12-12' 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: {Description: Name of an existing EC2 KeyPair to enable SSH access to the instances, Type: String} InstanceType: Description: WebServer EC2 instance type Type: String Default: m1.large AllowedValues: [t1.micro, m1.small, m1.large, m1.xlarge, m2.xlarge, m2.2xlarge, m2.4xlarge, c1.medium, c1.xlarge, cc1.4xlarge] ConstraintDescription: must be a valid EC2 instance type. DBName: {Default: wordpress, Description: The WordPress database name, Type: String, MinLength: '1', MaxLength: '64', AllowedPattern: '[a-zA-Z][a-zA-Z0-9]*', ConstraintDescription: must begin with a letter and contain only alphanumeric characters.} DBUsername: {Default: admin, NoEcho: 'true', Description: The WordPress database admin account username, Type: String, MinLength: '1', MaxLength: '16', AllowedPattern: '[a-zA-Z][a-zA-Z0-9]*', ConstraintDescription: must begin with a letter and contain only alphanumeric characters.} DBPassword: {Default: admin, NoEcho: 'true', Description: The WordPress database admin account password, Type: String, MinLength: '1', MaxLength: '41', AllowedPattern: '[a-zA-Z0-9]*', ConstraintDescription: must contain only alphanumeric characters.} DBRootPassword: {Default: admin, NoEcho: 'true', Description: Root password for MySQL, Type: String, MinLength: '1', MaxLength: '41', AllowedPattern: '[a-zA-Z0-9]*', ConstraintDescription: must contain only alphanumeric characters.} LinuxDistribution: Default: F17 Description: Distribution of choice Type: String AllowedValues: [F18, F17, U10, RHEL-6.1, RHEL-6.2, RHEL-6.3] Mappings: AWSInstanceType2Arch: t1.micro: {Arch: '32'} m1.small: {Arch: '32'} m1.large: {Arch: '64'} m1.xlarge: {Arch: '64'} m2.xlarge: {Arch: '64'} m2.2xlarge: {Arch: '64'} m2.4xlarge: {Arch: '64'} c1.medium: {Arch: '32'} c1.xlarge: {Arch: '64'} cc1.4xlarge: {Arch: '64'} DistroArch2AMI: F18: {'32': F18-i386-cfntools, '64': F18-x86_64-cfntools} F17: {'32': F17-i386-cfntools, '64': F17-x86_64-cfntools} U10: {'32': U10-i386-cfntools, '64': U10-x86_64-cfntools} RHEL-6.1: {'32': rhel61-i386-cfntools, '64': rhel61-x86_64-cfntools} RHEL-6.2: {'32': rhel62-i386-cfntools, '64': rhel62-x86_64-cfntools} RHEL-6.3: {'32': rhel63-i386-cfntools, '64': rhel63-x86_64-cfntools} Resources: WikiDatabase: Type: AWS::EC2::Instance Metadata: AWS::CloudFormation::Init: config: packages: yum: mysql: [] mysql-server: [] httpd: [] wordpress: [] services: systemd: mysqld: {enabled: 'true', ensureRunning: 'true'} httpd: {enabled: 'true', ensureRunning: 'true'} Properties: ImageId: Fn::FindInMap: - DistroArch2AMI - {Ref: LinuxDistribution} - Fn::FindInMap: - AWSInstanceType2Arch - {Ref: InstanceType} - Arch InstanceType: {Ref: InstanceType} KeyName: {Ref: KeyName} UserData: Fn::Base64: Fn::Join: - '' - - '#!/bin/bash -v ' - '/opt/aws/bin/cfn-init ' - '# Setup MySQL root password and create a user ' - mysqladmin -u root password ' - {Ref: DBRootPassword} - ''' ' - cat << EOF | mysql -u root --password=' - {Ref: DBRootPassword} - ''' ' - 'CREATE DATABASE ' - {Ref: DBName} - '; ' - 'GRANT ALL PRIVILEGES ON ' - {Ref: DBName} - .* TO " - {Ref: DBUsername} - '"@"localhost" ' - IDENTIFIED BY " - {Ref: DBPassword} - '"; ' - 'FLUSH PRIVILEGES; ' - 'EXIT ' - 'EOF ' - 'sed -i "/Deny from All/d" /etc/httpd/conf.d/wordpress.conf ' - 'sed -i "s/Require local/Require all granted/" /etc/httpd/conf.d/wordpress.conf ' - sed --in-place --e s/database_name_here/ - {Ref: DBName} - / --e s/username_here/ - {Ref: DBUsername} - / --e s/password_here/ - {Ref: DBPassword} - '/ /usr/share/wordpress/wp-config.php ' - 'systemctl restart httpd.service ' Outputs: WebsiteURL: Value: Fn::Join: - '' - - http:// - Fn::GetAtt: [WikiDatabase, PublicIp] - /wordpress Description: URL for Wordpress wiki heat-2014.1.5/heat/tests/templates/README0000664000567000056700000000053012540642611020765 0ustar jenkinsjenkins00000000000000These templates are required by test_template_format and test_provider_template in situations where we don't want to use a minimal template snippet. Ideally we want to test the maximum possible syntax to prove the format conversion works. In general, tests should not depend on these templates, inline minimal template snippets are preferred. heat-2014.1.5/heat/tests/templates/WordPress_Single_Instance.template0000664000567000056700000001324712540642611026730 0ustar jenkinsjenkins00000000000000{ "AWSTemplateFormatVersion" : "2010-09-09", "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" : { "Description" : "Name of an existing EC2 KeyPair to enable SSH access to the instances", "Type" : "String" }, "InstanceType" : { "Description" : "WebServer EC2 instance type", "Type" : "String", "Default" : "m1.large", "AllowedValues" : [ "t1.micro", "m1.small", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge" ], "ConstraintDescription" : "must be a valid EC2 instance type." }, "DBName": { "Default": "wordpress", "Description" : "The WordPress database name", "Type": "String", "MinLength": "1", "MaxLength": "64", "AllowedPattern" : "[a-zA-Z][a-zA-Z0-9]*", "ConstraintDescription" : "must begin with a letter and contain only alphanumeric characters." }, "DBUsername": { "Default": "admin", "NoEcho": "true", "Description" : "The WordPress database admin account username", "Type": "String", "MinLength": "1", "MaxLength": "16", "AllowedPattern" : "[a-zA-Z][a-zA-Z0-9]*", "ConstraintDescription" : "must begin with a letter and contain only alphanumeric characters." }, "DBPassword": { "Default": "admin", "NoEcho": "true", "Description" : "The WordPress database admin account password", "Type": "String", "MinLength": "1", "MaxLength": "41", "AllowedPattern" : "[a-zA-Z0-9]*", "ConstraintDescription" : "must contain only alphanumeric characters." }, "DBRootPassword": { "Default": "admin", "NoEcho": "true", "Description" : "Root password for MySQL", "Type": "String", "MinLength": "1", "MaxLength": "41", "AllowedPattern" : "[a-zA-Z0-9]*", "ConstraintDescription" : "must contain only alphanumeric characters." }, "LinuxDistribution": { "Default": "F17", "Description" : "Distribution of choice", "Type": "String", "AllowedValues" : [ "F18", "F17", "U10", "RHEL-6.1", "RHEL-6.2", "RHEL-6.3" ] } }, "Mappings" : { "AWSInstanceType2Arch" : { "t1.micro" : { "Arch" : "32" }, "m1.small" : { "Arch" : "32" }, "m1.large" : { "Arch" : "64" }, "m1.xlarge" : { "Arch" : "64" }, "m2.xlarge" : { "Arch" : "64" }, "m2.2xlarge" : { "Arch" : "64" }, "m2.4xlarge" : { "Arch" : "64" }, "c1.medium" : { "Arch" : "32" }, "c1.xlarge" : { "Arch" : "64" }, "cc1.4xlarge" : { "Arch" : "64" } }, "DistroArch2AMI": { "F18" : { "32" : "F18-i386-cfntools", "64" : "F18-x86_64-cfntools" }, "F17" : { "32" : "F17-i386-cfntools", "64" : "F17-x86_64-cfntools" }, "U10" : { "32" : "U10-i386-cfntools", "64" : "U10-x86_64-cfntools" }, "RHEL-6.1" : { "32" : "rhel61-i386-cfntools", "64" : "rhel61-x86_64-cfntools" }, "RHEL-6.2" : { "32" : "rhel62-i386-cfntools", "64" : "rhel62-x86_64-cfntools" }, "RHEL-6.3" : { "32" : "rhel63-i386-cfntools", "64" : "rhel63-x86_64-cfntools" } } }, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Metadata" : { "AWS::CloudFormation::Init" : { "config" : { "packages" : { "yum" : { "mysql" : [], "mysql-server" : [], "httpd" : [], "wordpress" : [] } }, "services" : { "systemd" : { "mysqld" : { "enabled" : "true", "ensureRunning" : "true" }, "httpd" : { "enabled" : "true", "ensureRunning" : "true" } } } } } }, "Properties": { "ImageId" : { "Fn::FindInMap" : [ "DistroArch2AMI", { "Ref" : "LinuxDistribution" }, { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ] } ] }, "InstanceType" : { "Ref" : "InstanceType" }, "KeyName" : { "Ref" : "KeyName" }, "UserData" : { "Fn::Base64" : { "Fn::Join" : ["", [ "#!/bin/bash -v\n", "/opt/aws/bin/cfn-init\n", "# Setup MySQL root password and create a user\n", "mysqladmin -u root password '", { "Ref" : "DBRootPassword" }, "'\n", "cat << EOF | mysql -u root --password='", { "Ref" : "DBRootPassword" }, "'\n", "CREATE DATABASE ", { "Ref" : "DBName" }, ";\n", "GRANT ALL PRIVILEGES ON ", { "Ref" : "DBName" }, ".* TO \"", { "Ref" : "DBUsername" }, "\"@\"localhost\"\n", "IDENTIFIED BY \"", { "Ref" : "DBPassword" }, "\";\n", "FLUSH PRIVILEGES;\n", "EXIT\n", "EOF\n", "sed -i \"/Deny from All/d\" /etc/httpd/conf.d/wordpress.conf\n", "sed -i \"s/Require local/Require all granted/\" /etc/httpd/conf.d/wordpress.conf\n", "sed --in-place --e s/database_name_here/", { "Ref" : "DBName" }, "/ --e s/username_here/", { "Ref" : "DBUsername" }, "/ --e s/password_here/", { "Ref" : "DBPassword" }, "/ /usr/share/wordpress/wp-config.php\n", "systemctl restart httpd.service\n" ]]}} } } }, "Outputs" : { "WebsiteURL" : { "Value" : { "Fn::Join" : ["", ["http://", { "Fn::GetAtt" : [ "WikiDatabase", "PublicIp" ]}, "/wordpress"]] }, "Description" : "URL for Wordpress wiki" } } } heat-2014.1.5/heat/tests/test_notifications.py0000664000567000056700000003372012540642614022403 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. import mock from oslo.config import cfg from heat.common import exception from heat.common import template_format from heat.engine import environment from heat.engine import parser from heat.engine import resource # imports for mocking from heat.engine.resources import autoscaling from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import loadbalancer from heat.engine.resources import nova_keypair from heat.engine.resources import user from heat.engine.resources import wait_condition as waitc from heat.engine import signal_responder as signal from heat.engine import stack_resource from heat.openstack.common import timeutils from heat.tests import common from heat.tests import generic_resource # reuse the same template than autoscaling tests from heat.tests.test_autoscaling import as_template from heat.tests import utils class NotificationTest(common.HeatTestCase): def setUp(self): super(NotificationTest, self).setUp() utils.setup_dummy_db() cfg.CONF.import_opt('notification_driver', 'heat.openstack.common.notifier.api') cfg.CONF.set_default('notification_driver', ['heat.openstack.common.notifier.test_notifier']) cfg.CONF.set_default('host', 'test_host') resource._register_class('GenericResource', generic_resource.ResourceWithProps) def create_test_stack(self): test_template = {'Parameters': {'Foo': {'Type': 'String'}, 'Pass': {'Type': 'String', 'NoEcho': True}}, 'Resources': {'TestResource': {'Type': 'GenericResource', 'Properties': {'Foo': 'abc'}}}, 'Outputs': {'food': {'Value': {'Fn::GetAtt': ['TestResource', 'foo']}}}} template = parser.Template(test_template) self.ctx = utils.dummy_context() self.ctx.tenant_id = 'test_tenant' env = environment.Environment() env.load({u'parameters': {u'Foo': 'user_data', u'Pass': 'secret'}}) self.stack_name = utils.random_name() stack = parser.Stack(self.ctx, self.stack_name, template, env=env, disable_rollback=True) self.stack = stack stack.store() self.created_time = stack.created_time self.create_at = timeutils.isotime(self.created_time) stack.create() self.expected = {} for action in ('create', 'suspend', 'delete'): self.make_mocks(action) def make_mocks(self, action): stack_arn = self.stack.identifier().arn() self.expected[action] = [ mock.call(self.ctx, 'orchestration.test_host', 'orchestration.stack.%s.start' % action, 'INFO', {'state_reason': 'Stack %s started' % action.upper(), 'user_id': 'test_username', 'stack_identity': stack_arn, 'tenant_id': 'test_tenant', 'create_at': self.create_at, 'stack_name': self.stack_name, 'state': '%s_IN_PROGRESS' % action.upper()}), mock.call(self.ctx, 'orchestration.test_host', 'orchestration.stack.%s.end' % action, 'INFO', {'state_reason': 'Stack %s completed successfully' % action.upper(), 'user_id': 'test_username', 'stack_identity': stack_arn, 'tenant_id': 'test_tenant', 'create_at': self.create_at, 'stack_name': self.stack_name, 'state': '%s_COMPLETE' % action.upper()})] @utils.stack_delete_after def test_create_stack(self): with mock.patch('heat.openstack.common.notifier.api.notify') \ as mock_notify: self.create_test_stack() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.assertEqual(self.expected['create'], mock_notify.call_args_list) @utils.stack_delete_after def test_create_and_suspend_stack(self): with mock.patch('heat.openstack.common.notifier.api.notify') \ as mock_notify: self.create_test_stack() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.assertEqual(self.expected['create'], mock_notify.call_args_list) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) expected = self.expected['create'] + self.expected['suspend'] self.assertEqual(expected, mock_notify.call_args_list) @utils.stack_delete_after def test_create_and_delete_stack(self): with mock.patch('heat.openstack.common.notifier.api.notify') \ as mock_notify: self.create_test_stack() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.assertEqual(self.expected['create'], mock_notify.call_args_list) self.stack.delete() self.assertEqual((self.stack.DELETE, self.stack.COMPLETE), self.stack.state) expected = self.expected['create'] + self.expected['delete'] self.assertEqual(expected, mock_notify.call_args_list) class ScaleNotificationTest(common.HeatTestCase): def setUp(self): super(ScaleNotificationTest, self).setUp() utils.setup_dummy_db() cfg.CONF.import_opt('notification_driver', 'heat.openstack.common.notifier.api') cfg.CONF.set_default('notification_driver', ['heat.openstack.common.notifier.test_notifier']) cfg.CONF.set_default('host', 'test_host') self.ctx = utils.dummy_context() self.ctx.tenant_id = 'test_tenant' def create_autoscaling_stack_and_get_group(self): env = environment.Environment() env.load({u'parameters': {u'KeyName': 'foo', 'ImageId': 'cloudimage'}}) t = template_format.parse(as_template) template = parser.Template(t) self.stack_name = utils.random_name() stack = parser.Stack(self.ctx, self.stack_name, template, env=env, disable_rollback=True) stack.store() self.created_time = stack.created_time self.create_at = timeutils.isotime(self.created_time) stack.create() self.stack = stack group = stack['WebServerGroup'] self.assertEqual((group.CREATE, group.COMPLETE), group.state) return group def mock_stack_except_for_group(self): self.m_validate = self.patchobject(parser.Stack, 'validate') self.patchobject(nova_keypair.KeypairConstraint, 'validate') self.patchobject(image.ImageConstraint, 'validate') self.patchobject(instance.Instance, 'handle_create')\ .return_value = True self.patchobject(instance.Instance, 'check_create_complete')\ .return_value = True self.patchobject(stack_resource.StackResource, 'check_update_complete').return_value = True self.patchobject(loadbalancer.LoadBalancer, 'handle_update') self.patchobject(user.User, 'handle_create') self.patchobject(user.AccessKey, 'handle_create') self.patchobject(waitc.WaitCondition, 'handle_create') self.patchobject(signal.SignalResponder, 'handle_create') def expected_notifs_calls(self, group, adjust, start_capacity, end_capacity=None, with_error=None): stack_arn = self.stack.identifier().arn() expected = [mock.call(self.ctx, 'orchestration.test_host', 'orchestration.autoscaling.start', 'INFO', {'state_reason': 'Stack CREATE completed successfully', 'user_id': 'test_username', 'stack_identity': stack_arn, 'tenant_id': 'test_tenant', 'create_at': self.create_at, 'adjustment_type': 'ChangeInCapacity', 'groupname': group.FnGetRefId(), 'capacity': start_capacity, 'adjustment': adjust, 'stack_name': self.stack_name, 'message': 'Start resizing the group %s' % group.FnGetRefId(), 'state': 'CREATE_COMPLETE'}) ] if with_error: expected += [mock.call(self.ctx, 'orchestration.test_host', 'orchestration.autoscaling.error', 'ERROR', {'state_reason': 'Stack CREATE completed successfully', 'user_id': 'test_username', 'stack_identity': stack_arn, 'tenant_id': 'test_tenant', 'create_at': self.create_at, 'adjustment_type': 'ChangeInCapacity', 'groupname': group.FnGetRefId(), 'capacity': start_capacity, 'adjustment': adjust, 'stack_name': self.stack_name, 'message': with_error, 'state': 'CREATE_COMPLETE'}) ] else: expected += [mock.call(self.ctx, 'orchestration.test_host', 'orchestration.autoscaling.end', 'INFO', {'state_reason': 'Stack CREATE completed successfully', 'user_id': 'test_username', 'stack_identity': stack_arn, 'tenant_id': 'test_tenant', 'create_at': self.create_at, 'adjustment_type': 'ChangeInCapacity', 'groupname': group.FnGetRefId(), 'capacity': end_capacity, 'adjustment': adjust, 'stack_name': self.stack_name, 'message': 'End resizing the group %s' % group.FnGetRefId(), 'state': 'CREATE_COMPLETE'}) ] return expected @utils.stack_delete_after def test_scale_success(self): with mock.patch('heat.engine.notification.stack.send'): with mock.patch('heat.openstack.common.notifier.api.notify') \ as mock_notify: self.mock_stack_except_for_group() group = self.create_autoscaling_stack_and_get_group() expected = self.expected_notifs_calls(group, adjust=1, start_capacity=1, end_capacity=2, ) group.adjust(1) self.assertEqual(2, len(group.get_instance_names())) mock_notify.assert_has_calls(expected) expected = self.expected_notifs_calls(group, adjust=-1, start_capacity=2, end_capacity=1, ) group.adjust(-1) self.assertEqual(1, len(group.get_instance_names())) mock_notify.assert_has_calls(expected) @utils.stack_delete_after def test_scaleup_failure(self): with mock.patch('heat.engine.notification.stack.send'): with mock.patch('heat.openstack.common.notifier.api.notify') \ as mock_notify: self.mock_stack_except_for_group() group = self.create_autoscaling_stack_and_get_group() err_message = 'Boooom' m_as = self.patchobject(autoscaling.AutoScalingGroup, 'resize') m_as.side_effect = exception.Error(err_message) expected = self.expected_notifs_calls(group, adjust=2, start_capacity=1, with_error=err_message, ) self.assertRaises(exception.Error, group.adjust, 2) self.assertEqual(1, len(group.get_instance_names())) mock_notify.assert_has_calls(expected) heat-2014.1.5/heat/tests/test_provider_template.py0000664000567000056700000007354512540642614023270 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. import json import os import uuid import yaml import testscenarios from heat.common import exception from heat.common import template_format from heat.common import urlfetch from heat.engine import environment from heat.engine import parser from heat.engine import properties from heat.engine import resource from heat.engine import resources from heat.engine.resources import template_resource from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import utils load_tests = testscenarios.load_tests_apply_scenarios class MyCloudResource(generic_rsrc.GenericResource): pass class ProviderTemplateTest(HeatTestCase): def setUp(self): super(ProviderTemplateTest, self).setUp() utils.setup_dummy_db() resource._register_class('OS::ResourceType', generic_rsrc.GenericResource) resource._register_class('myCloud::ResourceType', MyCloudResource) def test_get_os_empty_registry(self): # assertion: with an empty environment we get the correct # default class. env_str = {'resource_registry': {}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertEqual(generic_rsrc.GenericResource, cls) def test_get_mine_global_map(self): # assertion: with a global rule we get the "mycloud" class. env_str = {'resource_registry': {"OS::*": "myCloud::*"}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertEqual(MyCloudResource, cls) def test_get_mine_type_map(self): # assertion: with a global rule we get the "mycloud" class. env_str = {'resource_registry': { "OS::ResourceType": "myCloud::ResourceType"}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertEqual(MyCloudResource, cls) def test_get_mine_resource_map(self): # assertion: with a global rule we get the "mycloud" class. env_str = {'resource_registry': {'resources': {'fred': { "OS::ResourceType": "myCloud::ResourceType"}}}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertEqual(MyCloudResource, cls) def test_get_os_no_match(self): # assertion: make sure 'fred' doesn't match 'jerry'. env_str = {'resource_registry': {'resources': {'jerry': { "OS::ResourceType": "myCloud::ResourceType"}}}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertEqual(generic_rsrc.GenericResource, cls) def test_to_parameters(self): """Tests property conversion to parameter values.""" provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, 'AList': {'Type': 'CommaDelimitedList'}, 'ListEmpty': {'Type': 'CommaDelimitedList'}, 'ANum': {'Type': 'Number'}, 'AMap': {'Type': 'Json'}, }, 'Outputs': { 'Foo': {'Value': 'bar'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): attributes_schema = {"Foo": "A test attribute"} properties_schema = { "Foo": {"Type": "String"}, "AList": {"Type": "List"}, "ListEmpty": {"Type": "List"}, "ANum": {"Type": "Number"}, "AMap": {"Type": "Map"} } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) map_prop_val = { "key1": "val1", "key2": ["lval1", "lval2", "lval3"], "key3": { "key4": 4, "key5": False } } json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "Bar", "AList": ["one", "two", "three"], "ListEmpty": [], "ANum": 5, "AMap": map_prop_val } } temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) temp_res.validate() converted_params = temp_res.child_params() self.assertTrue(converted_params) for key in DummyResource.properties_schema: self.assertIn(key, converted_params) # verify String conversion self.assertEqual("Bar", converted_params.get("Foo")) # verify List conversion self.assertEqual(",".join(json_snippet.get("Properties", {}).get("AList", [])), converted_params.get("AList")) # verify Number conversion self.assertEqual(5, converted_params.get("ANum")) # verify Map conversion self.assertEqual(map_prop_val, converted_params.get("AMap")) def test_attributes_extra(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': {'Value': 'bar'}, 'Blarg': {'Value': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {"Foo": "A test attribute"} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) json_snippet = { "Type": "DummyResource", } temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertIsNone(temp_res.validate()) def test_attributes_missing(self): provider = { 'Outputs': { 'Blarg': {'Value': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {"Foo": "A test attribute"} json_snippet = { "Type": "DummyResource", } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) def test_properties_normal(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, 'Blarg': {'Type': 'String', 'Default': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.Schema.STRING, required=True)} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertIsNone(temp_res.validate()) def test_properties_missing(self): provider = { 'Parameters': { 'Blarg': {'Type': 'String', 'Default': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.Schema.STRING, required=True)} attributes_schema = {} json_snippet = { "Type": "DummyResource", } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) def test_properties_extra_required(self): provider = { 'Parameters': { 'Blarg': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Blarg": "wibble", }, } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) def test_properties_type_mismatch(self): provider = { 'Parameters': { 'Foo': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.Schema.MAP)} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) def test_get_template_resource(self): # assertion: if the name matches {.yaml|.template} we get the # TemplateResource class. env_str = {'resource_registry': {'resources': {'fred': { "OS::ResourceType": "some_magic.yaml"}}}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertEqual(template_resource.TemplateResource, cls) def test_get_template_resource_class(self): test_templ_name = 'file:///etc/heatr/frodo.yaml' minimal_temp = json.dumps({'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': {}, 'Resources': {}}) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('file',)).AndReturn(minimal_temp) self.m.ReplayAll() env_str = {'resource_registry': {'resources': {'fred': { "OS::ResourceType": test_templ_name}}}} env = environment.Environment(env_str) cls = env.get_class('OS::ResourceType', 'fred') self.assertNotEqual(template_resource.TemplateResource, cls) self.assertTrue(issubclass(cls, template_resource.TemplateResource)) self.assertTrue(hasattr(cls, "properties_schema")) self.assertTrue(hasattr(cls, "attributes_schema")) self.m.VerifyAll() def test_template_as_resource(self): """ Test that the resulting resource has the right prop and attrib schema. Note that this test requires the Wordpress_Single_Instance.yaml template in the templates directory since we want to test using a non-trivial template. """ test_templ_name = "WordPress_Single_Instance.yaml" path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'templates', test_templ_name) # check if its in the directory list vs. exists to work around # case-insensitive file systems self.assertIn(test_templ_name, os.listdir(os.path.dirname(path))) with open(path) as test_templ_file: test_templ = test_templ_file.read() self.assertTrue(test_templ, "Empty test template") self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('file',)).AndRaise(IOError) urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndReturn(test_templ) parsed_test_templ = template_format.parse(test_templ) self.m.ReplayAll() json_snippet = { "Type": test_templ_name, "Properties": { "KeyName": "mykeyname", "DBName": "wordpress1", "DBUsername": "wpdbuser", "DBPassword": "wpdbpass", "DBRootPassword": "wpdbrootpass", "LinuxDistribution": "U10" } } stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), stack_id=str(uuid.uuid4())) templ_resource = resource.Resource("test_templ_resource", json_snippet, stack) self.m.VerifyAll() self.assertIsInstance(templ_resource, template_resource.TemplateResource) for prop in parsed_test_templ.get("Parameters", {}): self.assertIn(prop, templ_resource.properties) for attrib in parsed_test_templ.get("Outputs", {}): self.assertIn(attrib, templ_resource.attributes) for k, v in json_snippet.get("Properties").items(): self.assertEqual(v, templ_resource.properties[k]) self.assertEqual( {'WordPress_Single_Instance.yaml': 'WordPress_Single_Instance.yaml', 'resources': {}}, stack.env.user_env_as_dict()["resource_registry"]) self.assertNotIn('WordPress_Single_Instance.yaml', resources.global_env().registry._registry) def test_persisted_unregistered_provider_templates(self): """ Test that templates persisted in the database prior to https://review.openstack.org/#/c/79953/1 are registered correctly. """ env = {'resource_registry': {'http://example.com/test.template': None, 'resources': {}}} #A KeyError will be thrown prior to this fix. environment.Environment(env=env) def test_system_template_retrieve_by_file(self): # make sure that a TemplateResource defined in the global environment # can be created and the template retrieved using the "file:" # scheme. g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), stack_id=str(uuid.uuid4())) minimal_temp = json.dumps({'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': {}, 'Resources': {}}) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https', 'file')).AndReturn(minimal_temp) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Frodo'}, stack) self.assertIsNone(temp_res.validate()) self.m.VerifyAll() def test_user_template_not_retrieved_by_file(self): # make sure that a TemplateResource defined in the user environment # can NOT be retrieved using the "file:" scheme, validation should fail env = environment.Environment() test_templ_name = 'file:///etc/heatr/flippy.yaml' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Flippy'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) def test_system_template_retrieve_fail(self): # make sure that a TemplateResource defined in the global environment # fails gracefully if the template file specified is inaccessible # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https', 'file')).AndRaise(IOError) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Frodo'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll() def test_user_template_retrieve_fail(self): # make sure that a TemplateResource defined in the user environment # fails gracefully if the template file specified is inaccessible # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() env = environment.Environment() test_templ_name = 'http://heatr/noexist.yaml' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndRaise(IOError) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Flippy'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll() def test_user_template_retrieve_fail_ext(self): # make sure that a TemplateResource defined in the user environment # fails gracefully if the template file is the wrong extension # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() env = environment.Environment() test_templ_name = 'http://heatr/letter_to_granny.docx' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=str(uuid.uuid4())) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Flippy'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll() class NestedProvider(HeatTestCase): """Prove that we can use the registry in a nested provider.""" def setUp(self): super(NestedProvider, self).setUp() utils.setup_dummy_db() def test_nested_env(self): main_templ = ''' heat_template_version: 2013-05-23 resources: secret2: type: My::NestedSecret outputs: secret1: value: { get_attr: [secret1, value] } ''' nested_templ = ''' heat_template_version: 2013-05-23 resources: secret2: type: My::Secret outputs: value: value: { get_attr: [secret2, value] } ''' env_templ = ''' resource_registry: "My::Secret": "OS::Heat::RandomString" "My::NestedSecret": nested.yaml ''' env = environment.Environment() env.load(yaml.load(env_templ)) templ = parser.Template(template_format.parse(main_templ), files={'nested.yaml': nested_templ}) stack = parser.Stack(utils.dummy_context(), utils.random_name(), templ, env=env) stack.store() stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) def test_no_infinite_recursion(self): """Prove that we can override a python resource. And use that resource within the template resource. """ main_templ = ''' heat_template_version: 2013-05-23 resources: secret2: type: OS::Heat::RandomString outputs: secret1: value: { get_attr: [secret1, value] } ''' nested_templ = ''' heat_template_version: 2013-05-23 resources: secret2: type: OS::Heat::RandomString outputs: value: value: { get_attr: [secret2, value] } ''' env_templ = ''' resource_registry: "OS::Heat::RandomString": nested.yaml ''' env = environment.Environment() env.load(yaml.load(env_templ)) templ = parser.Template(template_format.parse(main_templ), files={'nested.yaml': nested_templ}) stack = parser.Stack(utils.dummy_context(), utils.random_name(), templ, env=env) stack.store() stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) class ProviderTemplateUpdateTest(HeatTestCase): main_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_nested: Type: the.yaml Properties: one: my_name Outputs: identifier: Value: {Ref: the_nested} value: Value: {'Fn::GetAtt': [the_nested, the_str]} ''' main_template_2 = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_nested: Type: the.yaml Properties: one: updated_name Outputs: identifier: Value: {Ref: the_nested} value: Value: {'Fn::GetAtt': [the_nested, the_str]} ''' initial_tmpl = ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: one: Default: foo Type: String Resources: NestedResource: Type: OS::Heat::RandomString Properties: salt: {Ref: one} Outputs: the_str: Value: {'Fn::GetAtt': [NestedResource, value]} ''' prop_change_tmpl = ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: one: Default: yikes Type: String two: Default: foo Type: String Resources: NestedResource: Type: OS::Heat::RandomString Properties: salt: {Ref: one} Outputs: the_str: Value: {'Fn::GetAtt': [NestedResource, value]} ''' attr_change_tmpl = ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: one: Default: foo Type: String Resources: NestedResource: Type: OS::Heat::RandomString Properties: salt: {Ref: one} Outputs: the_str: Value: {'Fn::GetAtt': [NestedResource, value]} something_else: Value: just_a_string ''' content_change_tmpl = ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: one: Default: foo Type: String Resources: NestedResource: Type: OS::Heat::RandomString Properties: salt: yum Outputs: the_str: Value: {'Fn::GetAtt': [NestedResource, value]} ''' EXPECTED = (REPLACE, UPDATE, NOCHANGE) = ('replace', 'update', 'nochange') scenarios = [ ('no_changes', dict(template=main_template, provider=initial_tmpl, expect=NOCHANGE)), ('main_tmpl_change', dict(template=main_template_2, provider=initial_tmpl, expect=UPDATE)), ('provider_change', dict(template=main_template, provider=content_change_tmpl, expect=UPDATE)), ('provider_props_change', dict(template=main_template, provider=prop_change_tmpl, expect=REPLACE)), ('provider_attr_change', dict(template=main_template, provider=attr_change_tmpl, expect=REPLACE)), ] def setUp(self): super(ProviderTemplateUpdateTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context('test_username', 'aaaa', 'password') def create_stack(self): t = template_format.parse(self.main_template) tmpl = parser.Template(t, files={'the.yaml': self.initial_tmpl}) stack = parser.Stack(self.ctx, utils.random_name(), tmpl) stack.store() stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) return stack @utils.stack_delete_after def test_template_resource_update_template_schema(self): stack = self.create_stack() self.stack = stack initial_id = stack.output('identifier') initial_val = stack.output('value') tmpl = parser.Template(template_format.parse(self.template), files={'the.yaml': self.provider}) updated_stack = parser.Stack(self.ctx, stack.name, tmpl) stack.update(updated_stack) self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) if self.expect == self.REPLACE: self.assertNotEqual(initial_id, stack.output('identifier')) self.assertNotEqual(initial_val, stack.output('value')) elif self.expect == self.NOCHANGE: self.assertEqual(initial_id, stack.output('identifier')) self.assertEqual(initial_val, stack.output('value')) else: self.assertEqual(initial_id, stack.output('identifier')) self.assertNotEqual(initial_val, stack.output('value')) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_wsgi.py0000664000567000056700000004167312540642614020511 0ustar jenkinsjenkins00000000000000 # Copyright 2010-2011 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. import datetime import json from oslo.config import cfg import stubout import webob from heat.common import exception from heat.common import wsgi from heat.tests.common import HeatTestCase class RequestTest(HeatTestCase): def setUp(self): self.stubs = stubout.StubOutForTesting() super(RequestTest, self).setUp() def test_content_type_missing(self): request = wsgi.Request.blank('/tests/123') self.assertRaises(exception.InvalidContentType, request.get_content_type, ('application/xml')) def test_content_type_unsupported(self): request = wsgi.Request.blank('/tests/123') request.headers["Content-Type"] = "text/html" self.assertRaises(exception.InvalidContentType, request.get_content_type, ('application/xml')) def test_content_type_with_charset(self): request = wsgi.Request.blank('/tests/123') request.headers["Content-Type"] = "application/json; charset=UTF-8" result = request.get_content_type(('application/json')) self.assertEqual("application/json", result) def test_content_type_from_accept_xml(self): request = wsgi.Request.blank('/tests/123') request.headers["Accept"] = "application/xml" result = request.best_match_content_type() self.assertEqual("application/json", result) def test_content_type_from_accept_json(self): request = wsgi.Request.blank('/tests/123') request.headers["Accept"] = "application/json" result = request.best_match_content_type() self.assertEqual("application/json", result) def test_content_type_from_accept_xml_json(self): request = wsgi.Request.blank('/tests/123') request.headers["Accept"] = "application/xml, application/json" result = request.best_match_content_type() self.assertEqual("application/json", result) def test_content_type_from_accept_json_xml_quality(self): request = wsgi.Request.blank('/tests/123') request.headers["Accept"] = ("application/json; q=0.3, " "application/xml; q=0.9") result = request.best_match_content_type() self.assertEqual("application/json", result) def test_content_type_accept_default(self): request = wsgi.Request.blank('/tests/123.unsupported') request.headers["Accept"] = "application/unsupported1" result = request.best_match_content_type() self.assertEqual("application/json", result) def test_best_match_language(self): # Test that we are actually invoking language negotiation by webop request = wsgi.Request.blank('/') accepted = 'unknown-lang' request.headers = {'Accept-Language': accepted} def fake_best_match(self, offers, default_match=None): # Best match on an unknown locale returns None return None self.stubs.SmartSet(request.accept_language, 'best_match', fake_best_match) self.assertIsNone(request.best_match_language()) # If Accept-Language is missing or empty, match should be None request.headers = {'Accept-Language': ''} self.assertIsNone(request.best_match_language()) request.headers.pop('Accept-Language') self.assertIsNone(request.best_match_language()) class ResourceTest(HeatTestCase): def setUp(self): self.stubs = stubout.StubOutForTesting() super(ResourceTest, self).setUp() def test_get_action_args(self): env = { 'wsgiorg.routing_args': [ None, { 'controller': None, 'format': None, 'action': 'update', 'id': 12, }, ], } expected = {'action': 'update', 'id': 12} actual = wsgi.Resource(None, None, None).get_action_args(env) self.assertEqual(expected, actual) def test_get_action_args_invalid_index(self): env = {'wsgiorg.routing_args': []} expected = {} actual = wsgi.Resource(None, None, None).get_action_args(env) self.assertEqual(expected, actual) def test_get_action_args_del_controller_error(self): actions = {'format': None, 'action': 'update', 'id': 12} env = {'wsgiorg.routing_args': [None, actions]} expected = {'action': 'update', 'id': 12} actual = wsgi.Resource(None, None, None).get_action_args(env) self.assertEqual(expected, actual) def test_get_action_args_del_format_error(self): actions = {'action': 'update', 'id': 12} env = {'wsgiorg.routing_args': [None, actions]} expected = {'action': 'update', 'id': 12} actual = wsgi.Resource(None, None, None).get_action_args(env) self.assertEqual(expected, actual) def test_dispatch(self): class Controller(object): def index(self, shirt, pants=None): return (shirt, pants) resource = wsgi.Resource(None, None, None) actual = resource.dispatch(Controller(), 'index', 'on', pants='off') expected = ('on', 'off') self.assertEqual(expected, actual) def test_dispatch_default(self): class Controller(object): def default(self, shirt, pants=None): return (shirt, pants) resource = wsgi.Resource(None, None, None) actual = resource.dispatch(Controller(), 'index', 'on', pants='off') expected = ('on', 'off') self.assertEqual(expected, actual) def test_dispatch_no_default(self): class Controller(object): def show(self, shirt, pants=None): return (shirt, pants) resource = wsgi.Resource(None, None, None) self.assertRaises(AttributeError, resource.dispatch, Controller(), 'index', 'on', pants='off') def test_resource_call_error_handle(self): class Controller(object): def delete(self, req, identity): return (req, identity) actions = {'action': 'delete', 'id': 12, 'body': 'data'} env = {'wsgiorg.routing_args': [None, actions]} request = wsgi.Request.blank('/tests/123', environ=env) request.body = '{"foo" : "value"}' resource = wsgi.Resource(Controller(), wsgi.JSONRequestDeserializer(), None) # The Resource does not throw webob.HTTPExceptions, since they # would be considered responses by wsgi and the request flow would end, # instead they are wrapped so they can reach the fault application # where they are converted to a nice JSON/XML response e = self.assertRaises(exception.HTTPExceptionDisguise, resource, request) self.assertIsInstance(e.exc, webob.exc.HTTPBadRequest) def test_resource_call_error_handle_localized(self): class Controller(object): def delete(self, req, identity): return (req, identity) actions = {'action': 'delete', 'id': 12, 'body': 'data'} env = {'wsgiorg.routing_args': [None, actions]} request = wsgi.Request.blank('/tests/123', environ=env) request.body = '{"foo" : "value"}' message_es = "No Encontrado" translated_ex = webob.exc.HTTPBadRequest(message_es) resource = wsgi.Resource(Controller(), wsgi.JSONRequestDeserializer(), None) def fake_translate_exception(ex, locale): return translated_ex self.stubs.SmartSet(wsgi, 'translate_exception', fake_translate_exception) e = self.assertRaises(exception.HTTPExceptionDisguise, resource, request) self.assertEqual(message_es, str(e.exc)) self.m.VerifyAll() class ResourceExceptionHandlingTest(HeatTestCase): scenarios = [ ('client_exceptions', dict( exception=exception.StackResourceLimitExceeded, exception_catch=exception.StackResourceLimitExceeded)), ('webob_bad_request', dict( exception=webob.exc.HTTPBadRequest, exception_catch=exception.HTTPExceptionDisguise)), ('webob_not_found', dict( exception=webob.exc.HTTPNotFound, exception_catch=exception.HTTPExceptionDisguise)), ] def test_resource_client_exceptions_dont_log_error(self): class Controller(object): def __init__(self, excpetion_to_raise): self.excpetion_to_raise = excpetion_to_raise def raise_exception(self, req, body): raise self.excpetion_to_raise() actions = {'action': 'raise_exception', 'body': 'data'} env = {'wsgiorg.routing_args': [None, actions]} request = wsgi.Request.blank('/tests/123', environ=env) request.body = '{"foo" : "value"}' resource = wsgi.Resource(Controller(self.exception), wsgi.JSONRequestDeserializer(), None) e = self.assertRaises(self.exception_catch, resource, request) e = e.exc if hasattr(e, 'exc') else e self.assertNotIn(str(e), self.logger.output) class JSONResponseSerializerTest(HeatTestCase): def test_to_json(self): fixture = {"key": "value"} expected = '{"key": "value"}' actual = wsgi.JSONResponseSerializer().to_json(fixture) self.assertEqual(expected, actual) def test_to_json_with_date_format_value(self): fixture = {"date": datetime.datetime(1, 3, 8, 2)} expected = '{"date": "0001-03-08T02:00:00"}' actual = wsgi.JSONResponseSerializer().to_json(fixture) self.assertEqual(expected, actual) def test_to_json_with_more_deep_format(self): fixture = {"is_public": True, "name": [{"name1": "test"}]} expected = '{"is_public": true, "name": [{"name1": "test"}]}' actual = wsgi.JSONResponseSerializer().to_json(fixture) self.assertEqual(expected, actual) def test_default(self): fixture = {"key": "value"} response = webob.Response() wsgi.JSONResponseSerializer().default(response, fixture) self.assertEqual(200, response.status_int) content_types = filter(lambda h: h[0] == 'Content-Type', response.headerlist) self.assertEqual(1, len(content_types)) self.assertEqual('application/json', response.content_type) self.assertEqual('{"key": "value"}', response.body) class JSONRequestDeserializerTest(HeatTestCase): def test_has_body_no_content_length(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = 'asdf' request.headers.pop('Content-Length') request.headers['Content-Type'] = 'application/json' self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_zero_content_length(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = 'asdf' request.headers['Content-Length'] = 0 request.headers['Content-Type'] = 'application/json' self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_has_content_length_no_content_type(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_has_content_length_plain_content_type(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) request.headers['Content-Type'] = 'text/plain' self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_has_content_type_malformed(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = 'asdf' self.assertIn('Content-Length', request.headers) request.headers['Content-Type'] = 'application/json' self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_has_content_type(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) request.headers['Content-Type'] = 'application/json' self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_has_wrong_content_type(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) request.headers['Content-Type'] = 'application/xml' self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_has_aws_content_type_only(self): request = wsgi.Request.blank('/?ContentType=JSON') request.method = 'GET' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_respect_aws_content_type(self): request = wsgi.Request.blank('/?ContentType=JSON') request.method = 'GET' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) request.headers['Content-Type'] = 'application/xml' self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request)) def test_has_body_content_type_with_get(self): request = wsgi.Request.blank('/') request.method = 'GET' request.body = '{"key": "value"}' self.assertIn('Content-Length', request.headers) self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request)) def test_no_body_no_content_length(self): request = wsgi.Request.blank('/') self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request)) def test_from_json(self): fixture = '{"key": "value"}' expected = {"key": "value"} actual = wsgi.JSONRequestDeserializer().from_json(fixture) self.assertEqual(expected, actual) def test_from_json_malformed(self): fixture = 'kjasdklfjsklajf' self.assertRaises(webob.exc.HTTPBadRequest, wsgi.JSONRequestDeserializer().from_json, fixture) def test_default_no_body(self): request = wsgi.Request.blank('/') actual = wsgi.JSONRequestDeserializer().default(request) expected = {} self.assertEqual(expected, actual) def test_default_with_body(self): request = wsgi.Request.blank('/') request.method = 'POST' request.body = '{"key": "value"}' actual = wsgi.JSONRequestDeserializer().default(request) expected = {"body": {"key": "value"}} self.assertEqual(expected, actual) def test_default_with_get_with_body(self): request = wsgi.Request.blank('/') request.method = 'GET' request.body = '{"key": "value"}' actual = wsgi.JSONRequestDeserializer().default(request) expected = {"body": {"key": "value"}} self.assertEqual(expected, actual) def test_default_with_get_with_body_with_aws(self): request = wsgi.Request.blank('/?ContentType=JSON') request.method = 'GET' request.body = '{"key": "value"}' actual = wsgi.JSONRequestDeserializer().default(request) expected = {"body": {"key": "value"}} self.assertEqual(expected, actual) def test_from_json_exceeds_max_json_mb(self): cfg.CONF.set_override('max_json_body_size', 10) body = json.dumps(['a'] * cfg.CONF.max_json_body_size) self.assertTrue(len(body) > cfg.CONF.max_json_body_size) error = self.assertRaises(exception.RequestLimitExceeded, wsgi.JSONRequestDeserializer().from_json, body) msg = 'Request limit exceeded: JSON body size ' + \ '(%s bytes) exceeds maximum allowed size (%s bytes).' % \ (len(body), cfg.CONF.max_json_body_size) self.assertEqual(msg, str(error)) heat-2014.1.5/heat/tests/test_api_aws.py0000664000567000056700000002047012540642614021153 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. from heat.api.aws import utils as api_utils from heat.tests.common import HeatTestCase class AWSCommonTest(HeatTestCase): ''' Tests the api/aws common componenents ''' # The tests def test_format_response(self): response = api_utils.format_response("Foo", "Bar") expected = {'FooResponse': {'FooResult': 'Bar'}} self.assertEqual(expected, response) def test_params_extract(self): p = {'Parameters.member.1.ParameterKey': 'foo', 'Parameters.member.1.ParameterValue': 'bar', 'Parameters.member.2.ParameterKey': 'blarg', 'Parameters.member.2.ParameterValue': 'wibble'} params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') self.assertEqual(2, len(params)) self.assertIn('foo', params) self.assertEqual('bar', params['foo']) self.assertIn('blarg', params) self.assertEqual('wibble', params['blarg']) def test_params_extract_dots(self): p = {'Parameters.member.1.1.ParameterKey': 'foo', 'Parameters.member.1.1.ParameterValue': 'bar', 'Parameters.member.2.1.ParameterKey': 'blarg', 'Parameters.member.2.1.ParameterValue': 'wibble'} params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') self.assertFalse(params) def test_params_extract_garbage(self): p = {'Parameters.member.1.ParameterKey': 'foo', 'Parameters.member.1.ParameterValue': 'bar', 'Foo.1.ParameterKey': 'blarg', 'Foo.1.ParameterValue': 'wibble'} params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') self.assertEqual(1, len(params)) self.assertIn('foo', params) self.assertEqual('bar', params['foo']) def test_params_extract_garbage_prefix(self): p = {'prefixParameters.member.Foo.Bar.ParameterKey': 'foo', 'Parameters.member.Foo.Bar.ParameterValue': 'bar'} params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') self.assertFalse(params) def test_params_extract_garbage_suffix(self): p = {'Parameters.member.1.ParameterKeysuffix': 'foo', 'Parameters.member.1.ParameterValue': 'bar'} params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') self.assertFalse(params) def test_extract_param_list(self): p = {'MetricData.member.1.MetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(1, len(params)) self.assertIn('MetricName', params[0]) self.assertIn('Unit', params[0]) self.assertIn('Value', params[0]) self.assertEqual('foo', params[0]['MetricName']) self.assertEqual('Bytes', params[0]['Unit']) self.assertEqual(234333, params[0]['Value']) def test_extract_param_list_garbage_prefix(self): p = {'AMetricData.member.1.MetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(1, len(params)) self.assertNotIn('MetricName', params[0]) self.assertIn('Unit', params[0]) self.assertIn('Value', params[0]) self.assertEqual('Bytes', params[0]['Unit']) self.assertEqual(234333, params[0]['Value']) def test_extract_param_list_garbage_prefix2(self): p = {'AMetricData.member.1.MetricName': 'foo', 'BMetricData.member.1.Unit': 'Bytes', 'CMetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(0, len(params)) def test_extract_param_list_garbage_suffix(self): p = {'MetricData.member.1.AMetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(1, len(params)) self.assertNotIn('MetricName', params[0]) self.assertIn('Unit', params[0]) self.assertIn('Value', params[0]) self.assertEqual('Bytes', params[0]['Unit']) self.assertEqual(234333, params[0]['Value']) def test_extract_param_list_multiple(self): p = {'MetricData.member.1.MetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333, 'MetricData.member.2.MetricName': 'foo2', 'MetricData.member.2.Unit': 'Bytes', 'MetricData.member.2.Value': 12345} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(2, len(params)) self.assertIn('MetricName', params[0]) self.assertIn('MetricName', params[1]) self.assertEqual('foo', params[0]['MetricName']) self.assertEqual('Bytes', params[0]['Unit']) self.assertEqual(234333, params[0]['Value']) self.assertEqual('foo2', params[1]['MetricName']) self.assertEqual('Bytes', params[1]['Unit']) self.assertEqual(12345, params[1]['Value']) def test_extract_param_list_multiple_missing(self): # Handle case where there is an empty list item p = {'MetricData.member.1.MetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333, 'MetricData.member.3.MetricName': 'foo2', 'MetricData.member.3.Unit': 'Bytes', 'MetricData.member.3.Value': 12345} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(2, len(params)) self.assertIn('MetricName', params[0]) self.assertIn('MetricName', params[1]) self.assertEqual('foo', params[0]['MetricName']) self.assertEqual('Bytes', params[0]['Unit']) self.assertEqual(234333, params[0]['Value']) self.assertEqual('foo2', params[1]['MetricName']) self.assertEqual('Bytes', params[1]['Unit']) self.assertEqual(12345, params[1]['Value']) def test_extract_param_list_badindex(self): p = {'MetricData.member.xyz.MetricName': 'foo', 'MetricData.member.$!&^.Unit': 'Bytes', 'MetricData.member.+.Value': 234333, 'MetricData.member.--.MetricName': 'foo2', 'MetricData.member._3.Unit': 'Bytes', 'MetricData.member.-1000.Value': 12345} params = api_utils.extract_param_list(p, prefix='MetricData') self.assertEqual(0, len(params)) def test_reformat_dict_keys(self): keymap = {"foo": "bar"} data = {"foo": 123} expected = {"bar": 123} result = api_utils.reformat_dict_keys(keymap, data) self.assertEqual(expected, result) def test_reformat_dict_keys_missing(self): keymap = {"foo": "bar", "foo2": "bar2"} data = {"foo": 123} expected = {"bar": 123} result = api_utils.reformat_dict_keys(keymap, data) self.assertEqual(expected, result) heat-2014.1.5/heat/tests/testing-overview.txt0000664000567000056700000000263212540642614022201 0ustar jenkinsjenkins00000000000000Heat testing ------------ All tests are to be placed in the heat/tests directory. The directory is organized by test type (unit, functional, etc). Within each type directory one may create another directory for additional test files as well as a separate __init__.py, which should be blank. An example directory structure illustrating the above: heat/tests |-- examples | |-- __init__.py | |-- test1.py | |-- test2.py | |-- test3.py |-- __init__.py `-- unit |-- __init__.py |-- test_template_convert.py If a given test has no overlapping requirements (variables or same routines) a new test does not need to create a subdirectory under the test type. Implementing a test ------------------- Testrepository - http://pypi.python.org/pypi/testrepository is used to find and run tests, parallelize their runs, and record timing/results. If new dependencies are introduced upon the development of a test, the tools/test-requires file needs to be updated so that the virtual environment will be able to successfully execute all tests. Running the tests ----------------- During development, the simplest way to run tests is to simply invoke testr directly. $ testr run To run the tests with a clean virtual env in the same manner as the OpenStack testing infrastructure does so, use tox. $ tox -epy27 # test suite on python 2.7 $ tox -epy26 # test suite on python 2.6 $ tox -epep8 # run full source code checker heat-2014.1.5/heat/tests/test_api_cloudwatch.py0000664000567000056700000005652512540642614022530 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. import os from oslo.config import cfg from heat.api.aws import exception import heat.api.cloudwatch.watch as watches from heat.common import policy from heat.common.wsgi import Request from heat.openstack.common import rpc from heat.rpc import api as engine_api from heat.tests.common import HeatTestCase from heat.tests import utils class WatchControllerTest(HeatTestCase): ''' Tests the API class which acts as the WSGI controller, the endpoint processing API requests after they are routed ''' def _dummy_GET_request(self, params={}): # Mangle the params dict into a query string qs = "&".join(["=".join([k, str(params[k])]) for k in params]) environ = {'REQUEST_METHOD': 'GET', 'QUERY_STRING': qs} req = Request(environ) req.context = utils.dummy_context() return req # The tests def test_reformat_dimensions(self): dims = [{'StackId': u'21617058-781e-4262-97ab-5f9df371ee52', 'Foo': 'bar'}] self.assertEqual([{'Name': 'StackId', 'Value': u'21617058-781e-4262-97ab-5f9df371ee52'}, {'Name': 'Foo', 'Value': 'bar'}], self.controller._reformat_dimensions(dims) ) def test_enforce_default(self): self.m.ReplayAll() params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) self.controller.policy.policy_path = None response = self.controller._enforce(dummy_req, 'ListMetrics') self.assertIsNone(response) self.m.VerifyAll() def test_enforce_denied(self): self.m.ReplayAll() params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) dummy_req.context.roles = ['heat_stack_user'] self.controller.policy.policy_path = (self.policy_path + 'deny_stack_user.json') self.assertRaises(exception.HeatAccessDeniedError, self.controller._enforce, dummy_req, 'ListMetrics') self.m.VerifyAll() def test_enforce_ise(self): params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) dummy_req.context.roles = ['heat_stack_user'] self.m.StubOutWithMock(policy.Enforcer, 'enforce') policy.Enforcer.enforce(dummy_req.context, 'ListMetrics' ).AndRaise(AttributeError) self.m.ReplayAll() self.controller.policy.policy_path = (self.policy_path + 'deny_stack_user.json') self.assertRaises(exception.HeatInternalFailureError, self.controller._enforce, dummy_req, 'ListMetrics') self.m.VerifyAll() def test_delete(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DeleteAlarms'} dummy_req = self._dummy_GET_request(params) result = self.controller.delete_alarms(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_describe_alarm_history(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DescribeAlarmHistory'} dummy_req = self._dummy_GET_request(params) result = self.controller.describe_alarm_history(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_describe_all(self): watch_name = None # Get all watches # Format a dummy GET request to pass into the WSGI handler params = {'Action': 'DescribeAlarms'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response engine_resp = [{u'state_updated_time': u'2012-08-30T14:13:21Z', u'stack_id': u'21617058-781e-4262-97ab-5f9df371ee52', u'period': u'300', u'actions': [u'WebServerRestartPolicy'], u'topic': None, u'periods': u'1', u'statistic': u'SampleCount', u'threshold': u'2', u'unit': None, u'state_reason': None, u'dimensions': [], u'namespace': u'system/linux', u'state_value': u'NORMAL', u'ok_actions': None, u'description': u'Restart the WikiDatabase', u'actions_enabled': None, u'state_reason_data': None, u'insufficient_actions': None, u'metric_name': u'ServiceFailure', u'comparison': u'GreaterThanThreshold', u'name': u'HttpFailureAlarm', u'updated_time': u'2012-08-30T14:10:46Z'}] self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'namespace': None, 'args': {'watch_name': watch_name}, 'method': 'show_watch', 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() expected = {'DescribeAlarmsResponse': {'DescribeAlarmsResult': {'MetricAlarms': [ {'EvaluationPeriods': u'1', 'StateReasonData': None, 'AlarmArn': None, 'StateUpdatedTimestamp': u'2012-08-30T14:13:21Z', 'AlarmConfigurationUpdatedTimestamp': u'2012-08-30T14:10:46Z', 'AlarmActions': [u'WebServerRestartPolicy'], 'Threshold': u'2', 'AlarmDescription': u'Restart the WikiDatabase', 'Namespace': u'system/linux', 'Period': u'300', 'StateValue': u'NORMAL', 'ComparisonOperator': u'GreaterThanThreshold', 'AlarmName': u'HttpFailureAlarm', 'Unit': None, 'Statistic': u'SampleCount', 'StateReason': None, 'InsufficientDataActions': None, 'OKActions': None, 'MetricName': u'ServiceFailure', 'ActionsEnabled': None, 'Dimensions': [{'Name': 'StackId', 'Value': u'21617058-781e-4262-97ab-5f9df371ee52'}] }]}}} # Call the list controller function and compare the response self.assertEqual(expected, self.controller.describe_alarms(dummy_req)) def test_describe_alarms_for_metric(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DescribeAlarmsForMetric'} dummy_req = self._dummy_GET_request(params) result = self.controller.describe_alarms_for_metric(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_disable_alarm_actions(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'DisableAlarmActions'} dummy_req = self._dummy_GET_request(params) result = self.controller.disable_alarm_actions(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_enable_alarm_actions(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'EnableAlarmActions'} dummy_req = self._dummy_GET_request(params) result = self.controller.enable_alarm_actions(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_get_metric_statistics(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'GetMetricStatistics'} dummy_req = self._dummy_GET_request(params) result = self.controller.get_metric_statistics(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_list_metrics_all(self): params = {'Action': 'ListMetrics'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response # We dummy three different metrics and namespaces to test # filtering by parameter engine_resp = [{u'timestamp': u'2012-08-30T15:09:02Z', u'watch_name': u'HttpFailureAlarm', u'namespace': u'system/linux', u'metric_name': u'ServiceFailure', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:10:03Z', u'watch_name': u'HttpFailureAlarm2', u'namespace': u'system/linux2', u'metric_name': u'ServiceFailure2', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:16:03Z', u'watch_name': u'HttpFailureAlar3m', u'namespace': u'system/linux3', u'metric_name': u'ServiceFailure3', u'data': {u'Units': u'Counter', u'Value': 1}}] self.m.StubOutWithMock(rpc, 'call') # Current engine implementation means we filter in the API # and pass None/None for namespace/watch_name which returns # all metric data which we post-process in the API rpc.call(dummy_req.context, self.topic, {'namespace': None, 'args': {'metric_namespace': None, 'metric_name': None}, 'method': 'show_watch_metric', 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() expected = {'ListMetricsResponse': {'ListMetricsResult': {'Metrics': [{'Namespace': u'system/linux', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:09:02Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure'}, {'Namespace': u'system/linux2', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm2'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:10:03Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure2'}, {'Namespace': u'system/linux3', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlar3m'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:16:03Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure3'}]}}} # First pass no query paramters filtering, should get all three self.assertEqual(expected, self.controller.list_metrics(dummy_req)) def test_list_metrics_filter_name(self): # Add a MetricName filter, so we should only get one of the three params = {'Action': 'ListMetrics', 'MetricName': 'ServiceFailure'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response # We dummy three different metrics and namespaces to test # filtering by parameter engine_resp = [{u'timestamp': u'2012-08-30T15:09:02Z', u'watch_name': u'HttpFailureAlarm', u'namespace': u'system/linux', u'metric_name': u'ServiceFailure', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:10:03Z', u'watch_name': u'HttpFailureAlarm2', u'namespace': u'system/linux2', u'metric_name': u'ServiceFailure2', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:16:03Z', u'watch_name': u'HttpFailureAlar3m', u'namespace': u'system/linux3', u'metric_name': u'ServiceFailure3', u'data': {u'Units': u'Counter', u'Value': 1}}] self.m.StubOutWithMock(rpc, 'call') # Current engine implementation means we filter in the API # and pass None/None for namespace/watch_name which returns # all metric data which we post-process in the API rpc.call(dummy_req.context, self.topic, {'args': {'metric_namespace': None, 'metric_name': None}, 'namespace': None, 'method': 'show_watch_metric', 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() expected = {'ListMetricsResponse': {'ListMetricsResult': {'Metrics': [{'Namespace': u'system/linux', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:09:02Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure'}]}}} # First pass no query paramters filtering, should get all three self.assertEqual(expected, self.controller.list_metrics(dummy_req)) def test_list_metrics_filter_namespace(self): # Add a Namespace filter and change the engine response so # we should get two reponses params = {'Action': 'ListMetrics', 'Namespace': 'atestnamespace/foo'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to the engine with a pre-canned response # We dummy three different metrics and namespaces to test # filtering by parameter engine_resp = [{u'timestamp': u'2012-08-30T15:09:02Z', u'watch_name': u'HttpFailureAlarm', u'namespace': u'atestnamespace/foo', u'metric_name': u'ServiceFailure', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:10:03Z', u'watch_name': u'HttpFailureAlarm2', u'namespace': u'atestnamespace/foo', u'metric_name': u'ServiceFailure2', u'data': {u'Units': u'Counter', u'Value': 1}}, {u'timestamp': u'2012-08-30T15:16:03Z', u'watch_name': u'HttpFailureAlar3m', u'namespace': u'system/linux3', u'metric_name': u'ServiceFailure3', u'data': {u'Units': u'Counter', u'Value': 1}}] self.m.StubOutWithMock(rpc, 'call') # Current engine implementation means we filter in the API # and pass None/None for namespace/watch_name which returns # all metric data which we post-process in the API rpc.call(dummy_req.context, self.topic, {'args': {'metric_namespace': None, 'metric_name': None}, 'namespace': None, 'method': 'show_watch_metric', 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() expected = {'ListMetricsResponse': {'ListMetricsResult': {'Metrics': [{'Namespace': u'atestnamespace/foo', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:09:02Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure'}, {'Namespace': u'atestnamespace/foo', 'Dimensions': [{'Name': 'AlarmName', 'Value': u'HttpFailureAlarm2'}, {'Name': 'Timestamp', 'Value': u'2012-08-30T15:10:03Z'}, {'Name': u'Units', 'Value': u'Counter'}, {'Name': u'Value', 'Value': 1}], 'MetricName': u'ServiceFailure2'}]}}} self.assertEqual(expected, self.controller.list_metrics(dummy_req)) def test_put_metric_alarm(self): # Not yet implemented, should raise HeatAPINotImplementedError params = {'Action': 'PutMetricAlarm'} dummy_req = self._dummy_GET_request(params) result = self.controller.put_metric_alarm(dummy_req) self.assertIsInstance(result, exception.HeatAPINotImplementedError) def test_put_metric_data(self): params = {u'Namespace': u'system/linux', u'MetricData.member.1.Unit': u'Count', u'MetricData.member.1.Value': u'1', u'MetricData.member.1.MetricName': u'ServiceFailure', u'MetricData.member.1.Dimensions.member.1.Name': u'AlarmName', u'MetricData.member.1.Dimensions.member.1.Value': u'HttpFailureAlarm', u'Action': u'PutMetricData'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to verify the engine call parameters engine_resp = {} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'args': {'stats_data': {'Namespace': u'system/linux', u'ServiceFailure': {'Value': u'1', 'Unit': u'Count', 'Dimensions': []}}, 'watch_name': u'HttpFailureAlarm'}, 'namespace': None, 'method': 'create_watch_data', 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() expected = {'PutMetricDataResponse': {'PutMetricDataResult': {'ResponseMetadata': None}}} self.assertEqual(expected, self.controller.put_metric_data(dummy_req)) def test_set_alarm_state(self): state_map = {'OK': engine_api.WATCH_STATE_OK, 'ALARM': engine_api.WATCH_STATE_ALARM, 'INSUFFICIENT_DATA': engine_api.WATCH_STATE_NODATA} for state in state_map.keys(): params = {u'StateValue': state, u'StateReason': u'', u'AlarmName': u'HttpFailureAlarm', u'Action': u'SetAlarmState'} dummy_req = self._dummy_GET_request(params) # Stub out the RPC call to verify the engine call parameters # The real engine response is the same as show_watch but with # the state overridden, but since the API doesn't make use # of the response at present we pass nothing back from the stub engine_resp = {} self.m.StubOutWithMock(rpc, 'call') rpc.call(dummy_req.context, self.topic, {'args': {'state': state_map[state], 'watch_name': u'HttpFailureAlarm'}, 'namespace': None, 'method': 'set_watch_state', 'version': self.api_version}, None).AndReturn(engine_resp) self.m.ReplayAll() expected = {'SetAlarmStateResponse': {'SetAlarmStateResult': ''}} self.assertEqual(expected, self.controller.set_alarm_state(dummy_req)) self.m.UnsetStubs() self.m.VerifyAll() def test_set_alarm_state_badstate(self): params = {u'StateValue': "baaaaad", u'StateReason': u'', u'AlarmName': u'HttpFailureAlarm', u'Action': u'SetAlarmState'} dummy_req = self._dummy_GET_request(params) # should raise HeatInvalidParameterValueError result = self.controller.set_alarm_state(dummy_req) self.assertIsInstance(result, exception.HeatInvalidParameterValueError) def setUp(self): super(WatchControllerTest, self).setUp() self.path = os.path.dirname(os.path.realpath(__file__)) self.policy_path = self.path + "/policy/" opts = [ cfg.StrOpt('config_dir', default=self.policy_path), cfg.StrOpt('config_file', default='foo'), cfg.StrOpt('project', default='heat'), ] cfg.CONF.register_opts(opts) cfg.CONF.set_default('host', 'host') self.topic = engine_api.ENGINE_TOPIC self.api_version = '1.0' # Create WSGI controller instance class DummyConfig(): bind_port = 8003 cfgopts = DummyConfig() self.controller = watches.WatchController(options=cfgopts) self.controller.policy.enforcer.policy_path = (self.policy_path + 'deny_stack_user.json') self.addCleanup(self.m.VerifyAll) heat-2014.1.5/heat/tests/test_sqlalchemy_types.py0000664000567000056700000000345112540642614023116 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. from sqlalchemy.dialects.mysql.base import MySQLDialect from sqlalchemy.dialects.sqlite.base import SQLiteDialect from sqlalchemy import types import testtools from heat.db.sqlalchemy.types import Json from heat.db.sqlalchemy.types import LongText class LongTextTest(testtools.TestCase): def setUp(self): super(LongTextTest, self).setUp() self.sqltype = LongText() def test_load_dialect_impl(self): dialect = MySQLDialect() impl = self.sqltype.load_dialect_impl(dialect) self.assertNotEqual(types.Text, type(impl)) dialect = SQLiteDialect() impl = self.sqltype.load_dialect_impl(dialect) self.assertEqual(types.Text, type(impl)) class JsonTest(testtools.TestCase): def setUp(self): super(JsonTest, self).setUp() self.sqltype = Json() def test_process_bind_param(self): dialect = None value = {'foo': 'bar'} result = self.sqltype.process_bind_param(value, dialect) self.assertEqual('{"foo": "bar"}', result) def test_process_result_value(self): dialect = None value = '{"foo": "bar"}' result = self.sqltype.process_result_value(value, dialect) self.assertEqual({'foo': 'bar'}, result) heat-2014.1.5/heat/tests/v1_1/0000775000567000056700000000000012540643116016660 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/v1_1/testfile.txt0000664000567000056700000000000512540642614021235 0ustar jenkinsjenkins00000000000000BLAH heat-2014.1.5/heat/tests/v1_1/fakes.py0000664000567000056700000004152612540642614020335 0ustar jenkinsjenkins00000000000000# Copyright (c) 2011 X.commerce, a business unit of eBay Inc. # Copyright 2011 OpenStack Foundation # # 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. import httplib2 import mock from novaclient import client as base_client from novaclient import exceptions as nova_exceptions from novaclient.v1_1 import client from heat.openstack.common.py3kcompat import urlutils from heat.tests import fakes def fake_exception(status_code=404, message=None, details=None): resp = mock.Mock() resp.status_code = status_code resp.headers = None body = {'error': {'message': message, 'details': details}} return nova_exceptions.from_response(resp, body, None) class FakeClient(fakes.FakeClient, client.Client): def __init__(self, *args, **kwargs): client.Client.__init__(self, 'username', 'password', 'project_id', 'auth_url') self.client = FakeHTTPClient(**kwargs) class FakeHTTPClient(base_client.HTTPClient): def __init__(self, **kwargs): self.username = 'username' self.password = 'password' self.auth_url = 'auth_url' self.callstack = [] def _cs_request(self, url, method, **kwargs): # Check that certain things are called correctly if method in ['GET', 'DELETE']: assert 'body' not in kwargs elif method == 'PUT': assert 'body' in kwargs # Call the method args = urlutils.parse_qsl(urlutils.urlparse(url)[4]) kwargs.update(args) munged_url = url.rsplit('?', 1)[0] munged_url = munged_url.strip('/').replace('/', '_').replace('.', '_') munged_url = munged_url.replace('-', '_') callback = "%s_%s" % (method.lower(), munged_url) if not hasattr(self, callback): raise AssertionError('Called unknown API method: %s %s, ' 'expected fakes method name: %s' % (method, url, callback)) # Note the call self.callstack.append((method, url, kwargs.get('body'))) status, body = getattr(self, callback)(**kwargs) if hasattr(status, 'items'): return httplib2.Response(status), body else: return httplib2.Response({"status": status}), body # # Servers # def get_servers_detail(self, **kw): return ( 200, {"servers": [{"id": 1234, "name": "sample-server", "OS-EXT-SRV-ATTR:instance_name": "sample-server", "image": {"id": 2, "name": "sample image"}, "flavor": {"id": 1, "name": "256 MB Server"}, "hostId": "e4d909c290d0fb1ca068ffaddf22cbd0", "status": "BUILD", "progress": 60, "addresses": {"public": [{"version": 4, "addr": "1.2.3.4"}, {"version": 4, "addr": "5.6.7.8"}], "private": [{"version": 4, "addr": "10.11.12.13"}]}, "accessIPv4": "", "accessIPv6": "", "metadata": {"Server Label": "Web Head 1", "Image Version": "2.1"}}, {"id": 5678, "name": "sample-server2", "OS-EXT-SRV-ATTR:instance_name": "sample-server2", "image": {"id": 2, "name": "sample image"}, "flavor": {"id": 1, "name": "256 MB Server"}, "hostId": "9e107d9d372bb6826bd81d3542a419d6", "status": "ACTIVE", "accessIPv4": "192.0.2.0", "accessIPv6": "::babe:4317:0A83", "addresses": {"public": [{"version": 4, "addr": "4.5.6.7", "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:8c:22:aa"}, {"version": 4, "addr": "5.6.9.8", "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:8c:33:bb"}], "private": [{"version": 4, "addr": "10.13.12.13", "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:8c:44:cc"}]}, "metadata": {}}, {"id": 9101, "name": "hard-reboot", "OS-EXT-SRV-ATTR:instance_name": "hard-reboot", "image": {"id": 2, "name": "sample image"}, "flavor": {"id": 1, "name": "256 MB Server"}, "hostId": "9e44d8d435c43dd8d96bb63ed995605f", "status": "HARD_REBOOT", "accessIPv4": "", "accessIPv6": "", "addresses": {"public": [{"version": 4, "addr": "172.17.1.2"}, {"version": 4, "addr": "10.20.30.40"}], "private": [{"version": 4, "addr": "10.13.12.13"}]}, "metadata": {"Server Label": "DB 1"}}, {"id": 9102, "name": "server-with-no-ip", "OS-EXT-SRV-ATTR:instance_name": "server-with-no-ip", "image": {"id": 2, "name": "sample image"}, "flavor": {"id": 1, "name": "256 MB Server"}, "hostId": "c1365ba78c624df9b2ff446515a682f5", "status": "ACTIVE", "accessIPv4": "", "accessIPv6": "", "addresses": {"empty_net": []}, "metadata": {"Server Label": "DB 1"}}, {"id": 9999, "name": "sample-server3", "OS-EXT-SRV-ATTR:instance_name": "sample-server3", "image": {"id": 3, "name": "sample image"}, "flavor": {"id": 3, "name": "m1.large"}, "hostId": "9e107d9d372bb6826bd81d3542a419d6", "status": "ACTIVE", "accessIPv4": "", "accessIPv6": "", "addresses": { "public": [{"version": 4, "addr": "4.5.6.7"}, {"version": 4, "addr": "5.6.9.8"}], "private": [{"version": 4, "addr": "10.13.12.13"}]}, "metadata": {"Server Label": "DB 1"}}, {"id": 56789, "name": "server-with-metadata", "OS-EXT-SRV-ATTR:instance_name": "sample-server2", "image": {"id": 2, "name": "sample image"}, "flavor": {"id": 1, "name": "256 MB Server"}, "hostId": "9e107d9d372bb6826bd81d3542a419d6", "status": "ACTIVE", "accessIPv4": "192.0.2.0", "accessIPv6": "::babe:4317:0A83", "addresses": {"public": [{"version": 4, "addr": "4.5.6.7"}, {"version": 4, "addr": "5.6.9.8"}], "private": [{"version": 4, "addr": "10.13.12.13"}]}, "metadata": {'test': '123', 'this': 'that'}}]}) def get_servers_1234(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][0]} return (200, r) def get_servers_56789(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][5]} return (200, r) def get_servers_WikiServerOne(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][0]} return (200, r) def get_servers_WikiServerOne1(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][0]} return (200, r) def get_servers_WikiServerOne2(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][3]} return (200, r) def get_servers_5678(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][1]} return (200, r) def delete_servers_1234(self, **kw): return (202, None) def get_servers_9999(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][0]} return (200, r) def get_servers_9102(self, **kw): r = {'server': self.get_servers_detail()[1]['servers'][3]} return (200, r) # # Server actions # def post_servers_1234_action(self, body, **kw): _body = None resp = 202 assert len(body.keys()) == 1 action = body.keys()[0] if action == 'reboot': assert body[action].keys() == ['type'] assert body[action]['type'] in ['HARD', 'SOFT'] elif action == 'rebuild': keys = body[action].keys() if 'adminPass' in keys: keys.remove('adminPass') assert keys == ['imageRef'] _body = self.get_servers_1234()[1] elif action == 'resize': assert body[action].keys() == ['flavorRef'] elif action == 'confirmResize': assert body[action] is None # This one method returns a different response code return (204, None) elif action == 'revertResize': assert body[action] is None elif action == 'migrate': assert body[action] is None elif action == 'rescue': assert body[action] is None elif action == 'unrescue': assert body[action] is None elif action == 'lock': assert body[action] is None elif action == 'unlock': assert body[action] is None elif action == 'suspend': assert body[action] is None elif action == 'resume': assert body[action] is None elif action == 'addFixedIp': assert body[action].keys() == ['networkId'] elif action == 'removeFixedIp': assert body[action].keys() == ['address'] elif action == 'addFloatingIp': assert body[action].keys() == ['address'] elif action == 'removeFloatingIp': assert body[action].keys() == ['address'] elif action == 'createImage': assert set(body[action].keys()) == set(['name', 'metadata']) resp = dict(status=202, location="http://blah/images/456") elif action == 'changePassword': assert body[action].keys() == ['adminPass'] elif action == 'os-getConsoleOutput': assert body[action].keys() == ['length'] return (202, {'output': 'foo'}) elif action == 'os-getVNCConsole': assert body[action].keys() == ['type'] elif action == 'os-migrateLive': assert set(body[action].keys()) == set(['host', 'block_migration', 'disk_over_commit']) else: raise AssertionError("Unexpected server action: %s" % action) return (resp, _body) # # Flavors # def get_flavors_detail(self, **kw): return (200, {'flavors': [ {'id': 1, 'name': '256 MB Server', 'ram': 256, 'disk': 10, 'OS-FLV-EXT-DATA:ephemeral': 10}, {'id': 2, 'name': 'm1.small', 'ram': 512, 'disk': 20, 'OS-FLV-EXT-DATA:ephemeral': 20}, {'id': 3, 'name': 'm1.large', 'ram': 512, 'disk': 20, 'OS-FLV-EXT-DATA:ephemeral': 30} ]}) # # Floating ips # def get_os_floating_ips_1(self, **kw): return (200, {'floating_ip': {'id': 1, 'fixed_ip': '10.0.0.1', 'ip': '11.0.0.1'}}) def post_os_floating_ips(self, body, **kw): return (202, self.get_os_floating_ips_1()[1]) def delete_os_floating_ips_1(self, **kw): return (204, None) # # Images # def get_images_detail(self, **kw): return (200, {'images': [{'id': 1, 'name': 'CentOS 5.2', "updated": "2010-10-10T12:00:00Z", "created": "2010-08-10T12:00:00Z", "status": "ACTIVE", "metadata": {"test_key": "test_value"}, "links": {}}, {"id": 743, "name": "My Server Backup", "serverId": 1234, "updated": "2010-10-10T12:00:00Z", "created": "2010-08-10T12:00:00Z", "status": "SAVING", "progress": 80, "links": {}}, {"id": 744, "name": "F17-x86_64-gold", "serverId": 9999, "updated": "2010-10-10T12:00:00Z", "created": "2010-08-10T12:00:00Z", "status": "SAVING", "progress": 80, "links": {}}, {"id": 745, "name": "F17-x86_64-cfntools", "serverId": 9998, "updated": "2010-10-10T12:00:00Z", "created": "2010-08-10T12:00:00Z", "status": "SAVING", "progress": 80, "links": {}}, {"id": 746, "name": "F20-x86_64-cfntools", "serverId": 9998, "updated": "2010-10-10T12:00:00Z", "created": "2010-08-10T12:00:00Z", "status": "SAVING", "progress": 80, "links": {}}]}) def get_images_1(self, **kw): return (200, {'image': self.get_images_detail()[1]['images'][0]}) # # Keypairs # def get_os_keypairs(self, *kw): return (200, {"keypairs": [{'fingerprint': 'FAKE_KEYPAIR', 'name': 'test', 'public_key': 'foo'}]}) def get_os_availability_zone(self, *kw): return (200, {"availabilityZoneInfo": [{'zoneName': 'nova1'}]}) def get_os_networks(self, **kw): return (200, {'networks': [{'label': 'public', 'id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}, {'label': 'foo', 'id': '42'}, {'label': 'foo', 'id': '42'}]}) # # Limits # def get_limits(self, *kw): return (200, {'limits': {'absolute': {'maxServerMeta': 3, 'maxPersonalitySize': 10240, 'maxPersonality': 5}}}) heat-2014.1.5/heat/tests/v1_1/__init__.py0000664000567000056700000000000012540642614020761 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/tests/test_server.py0000664000567000056700000031430112540642614021035 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. import collections import copy import uuid import mock import mox from novaclient import exceptions from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.engine.resources import image from heat.engine.resources import nova_utils from heat.engine.resources import server as servers from heat.engine.resources.software_config import software_config as sc from heat.engine import scheduler from heat.openstack.common.gettextutils import _ from heat.openstack.common import uuidutils from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils from heat.tests.v1_1 import fakes as fakes_v1_1 wp_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "key_name" : { "Description" : "key_name", "Type" : "String", "Default" : "test" } }, "Resources" : { "WebServer": { "Type": "OS::Nova::Server", "Properties": { "image" : "F17-x86_64-gold", "flavor" : "m1.large", "key_name" : "test", "user_data" : "wordpress" } } } } ''' class ServersTest(HeatTestCase): def setUp(self): super(ServersTest, self).setUp() self.fc = fakes_v1_1.FakeClient() self.fkc = fakes.FakeKeystoneClient() utils.setup_dummy_db() self.limits = self.m.CreateMockAnything() self.limits.absolute = self._limits_absolute() def _limits_absolute(self): max_personality = self.m.CreateMockAnything() max_personality.name = 'maxPersonality' max_personality.value = 5 max_personality_size = self.m.CreateMockAnything() max_personality_size.name = 'maxPersonalitySize' max_personality_size.value = 10240 max_server_meta = self.m.CreateMockAnything() max_server_meta.name = 'maxServerMeta' max_server_meta.value = 3 yield max_personality yield max_personality_size yield max_server_meta def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'key_name': 'test'}), stack_id=str(uuid.uuid4()), stack_user_project_id='8888') return (t, stack) def _setup_test_server(self, return_server, name, image_id=None, override_name=False, stub_create=True): stack_name = '%s_s' % name (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['image'] = \ image_id or 'CentOS 5.2' t['Resources']['WebServer']['Properties']['flavor'] = \ '256 MB Server' server_name = '%s' % name if override_name: t['Resources']['WebServer']['Properties']['name'] = \ server_name server = servers.Server(server_name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) server.t = server.stack.resolve_runtime_data(server.t) if stub_create: self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=override_name and server.name or utils.PhysName( stack_name, server.name), security_groups=[], userdata=mox.IgnoreArg(), scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn(return_server) return server def _create_test_server(self, return_server, name, override_name=False, stub_create=True): server = self._setup_test_server(return_server, name, stub_create=stub_create) self.m.ReplayAll() scheduler.TaskRunner(server.create)() return server def _create_fake_iface(self, port, mac, ip): class fake_interface(): def __init__(self, port_id, mac_addr, fixed_ip): self.port_id = port_id self.mac_addr = mac_addr self.fixed_ips = [{'ip_address': fixed_ip}] return fake_interface(port, mac, ip) def test_server_create(self): return_server = self.fc.servers.list()[1] return_server.id = 5678 server = self._create_test_server(return_server, 'test_server_create') # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) interfaces = [ self._create_fake_iface('1234', 'fa:16:3e:8c:22:aa', '4.5.6.7'), self._create_fake_iface('5678', 'fa:16:3e:8c:33:bb', '5.6.9.8'), self._create_fake_iface( '1013', 'fa:16:3e:8c:44:cc', '10.13.12.13')] self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(5678).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(return_server, 'interface_list') return_server.interface_list().MultipleTimes().AndReturn(interfaces) self.m.ReplayAll() public_ip = return_server.networks['public'][0] self.assertEqual('1234', server.FnGetAtt('addresses')['public'][0]['port']) self.assertEqual('5678', server.FnGetAtt('addresses')['public'][1]['port']) self.assertEqual(public_ip, server.FnGetAtt('addresses')['public'][0]['addr']) self.assertEqual(public_ip, server.FnGetAtt('networks')['public'][0]) private_ip = return_server.networks['private'][0] self.assertEqual('1013', server.FnGetAtt('addresses')['private'][0]['port']) self.assertEqual(private_ip, server.FnGetAtt('addresses')['private'][0]['addr']) self.assertEqual(private_ip, server.FnGetAtt('networks')['private'][0]) self.assertIn( server.FnGetAtt('first_address'), (private_ip, public_ip)) self.assertEqual(return_server._info, server.FnGetAtt('show')) self.assertEqual('sample-server2', server.FnGetAtt('instance_name')) self.assertEqual('192.0.2.0', server.FnGetAtt('accessIPv4')) self.assertEqual('::babe:4317:0A83', server.FnGetAtt('accessIPv6')) self.m.VerifyAll() def test_server_create_metadata(self): return_server = self.fc.servers.list()[1] stack_name = 'create_metadata_test_stack' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['metadata'] = \ {'a': 1} server = servers.Server('create_metadata_test_server', t['Resources']['WebServer'], stack) server.t = server.stack.resolve_runtime_data(server.t) instance_meta = {'a': "1"} self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=mox.IgnoreArg(), flavor=mox.IgnoreArg(), key_name='test', name=mox.IgnoreArg(), security_groups=[], userdata=mox.IgnoreArg(), scheduler_hints=None, meta=instance_meta, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn(return_server) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_server_create_with_image_id(self): return_server = self.fc.servers.list()[1] return_server.id = 5678 server = self._setup_test_server(return_server, 'test_server_create_image_id', image_id='1', override_name=True) self.m.StubOutWithMock(uuidutils, "is_uuid_like") uuidutils.is_uuid_like('1').MultipleTimes().AndReturn(True) interfaces = [ self._create_fake_iface('1234', 'fa:16:3e:8c:22:aa', '4.5.6.7'), self._create_fake_iface('5678', 'fa:16:3e:8c:33:bb', '5.6.9.8'), self._create_fake_iface( '1013', 'fa:16:3e:8c:44:cc', '10.13.12.13')] self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(5678).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(return_server, 'interface_list') return_server.interface_list().MultipleTimes().AndReturn(interfaces) self.m.ReplayAll() scheduler.TaskRunner(server.create)() # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) public_ip = return_server.networks['public'][0] self.assertEqual('1234', server.FnGetAtt('addresses')['public'][0]['port']) self.assertEqual('5678', server.FnGetAtt('addresses')['public'][1]['port']) self.assertEqual( server.FnGetAtt('addresses')['public'][0]['addr'], public_ip) self.assertEqual( server.FnGetAtt('networks')['public'][0], public_ip) private_ip = return_server.networks['private'][0] self.assertEqual('1013', server.FnGetAtt('addresses')['private'][0]['port']) self.assertEqual( server.FnGetAtt('addresses')['private'][0]['addr'], private_ip) self.assertEqual( server.FnGetAtt('networks')['private'][0], private_ip) self.assertIn( server.FnGetAtt('first_address'), (private_ip, public_ip)) self.m.VerifyAll() def test_server_create_image_name_err(self): stack_name = 'img_name_err' (t, stack) = self._setup_test_stack(stack_name) # create an server with non exist image name t['Resources']['WebServer']['Properties']['image'] = 'Slackware' server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() error = self.assertRaises(ValueError, server.handle_create) self.assertEqual( 'server_create_image_err: image "Slackware" does not ' 'validate glance.image', str(error)) self.m.VerifyAll() def test_server_create_duplicate_image_name_err(self): stack_name = 'img_dup_err' (t, stack) = self._setup_test_stack(stack_name) # create an server with a non unique image name t['Resources']['WebServer']['Properties']['image'] = 'CentOS 5.2' server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(self.fc.client, "get_images_detail") self.fc.client.get_images_detail().AndReturn(( 200, {'images': [{'id': 1, 'name': 'CentOS 5.2'}, {'id': 4, 'name': 'CentOS 5.2'}]})) self.m.ReplayAll() error = self.assertRaises(ValueError, server.handle_create) self.assertEqual( 'server_create_image_err: image Multiple physical resources were ' 'found with name (CentOS 5.2).', str(error)) self.m.VerifyAll() def test_server_create_image_id_err(self): stack_name = 'img_id_err' (t, stack) = self._setup_test_stack(stack_name) # create an server with non exist image Id t['Resources']['WebServer']['Properties']['image'] = '1' server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(uuidutils, "is_uuid_like") uuidutils.is_uuid_like('1').AndReturn(True) self.m.StubOutWithMock(self.fc.client, "get_images_1") self.fc.client.get_images_1().AndRaise( servers.clients.novaclient.exceptions.NotFound(404)) self.m.ReplayAll() error = self.assertRaises(ValueError, server.handle_create) self.assertEqual( 'server_create_image_err: image "1" does not ' 'validate glance.image', str(error)) self.m.VerifyAll() def test_server_create_unexpected_status(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'cr_unexp_sts') return_server.get = lambda: None return_server.status = 'BOGUS' self.assertRaises(exception.Error, server.check_create_complete, return_server) def test_server_create_error_status(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'cr_err_sts') return_server.status = 'ERROR' return_server.fault = { 'message': 'NoValidHost', 'code': 500, 'created': '2013-08-14T03:12:10Z' } self.m.StubOutWithMock(return_server, 'get') return_server.get() self.m.ReplayAll() self.assertRaises(exception.Error, server.check_create_complete, return_server) self.m.VerifyAll() def test_server_create_raw_userdata(self): return_server = self.fc.servers.list()[1] stack_name = 'raw_userdata_s' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['user_data_format'] = \ 'RAW' server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) server.t = server.stack.resolve_runtime_data(server.t) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata='wordpress', scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn( return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_server_create_raw_config_userdata(self): return_server = self.fc.servers.list()[1] stack_name = 'raw_userdata_s' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['user_data_format'] = \ 'RAW' t['Resources']['WebServer']['Properties']['user_data'] = \ '8c813873-f6ee-4809-8eec-959ef39acb55' server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') self.m.StubOutWithMock(server, 'heat') self.m.StubOutWithMock(sc.SoftwareConfig, 'get_software_config') server.heat().AndReturn(None) sc.SoftwareConfig.get_software_config( None, '8c813873-f6ee-4809-8eec-959ef39acb55').AndReturn( 'wordpress from config') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) server.t = server.stack.resolve_runtime_data(server.t) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata='wordpress from config', scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn( return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_server_create_raw_config_userdata_None(self): return_server = self.fc.servers.list()[1] stack_name = 'raw_userdata_s' (t, stack) = self._setup_test_stack(stack_name) sc_id = '8c813873-f6ee-4809-8eec-959ef39acb55' t['Resources']['WebServer']['Properties']['user_data_format'] = \ 'RAW' t['Resources']['WebServer']['Properties']['user_data'] = sc_id server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') self.m.StubOutWithMock(server, 'heat') self.m.StubOutWithMock(sc.SoftwareConfig, 'get_software_config') server.heat().AndReturn(None) sc.SoftwareConfig.get_software_config( None, sc_id).AndRaise(exception.SoftwareConfigMissing( software_config_id=sc_id)) server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) server.t = server.stack.resolve_runtime_data(server.t) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata=sc_id, scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn(return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_server_create_software_config(self): return_server = self.fc.servers.list()[1] stack_name = 'software_config_s' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['user_data_format'] = \ 'SOFTWARE_CONFIG' stack.stack_user_project_id = '8888' server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') self.m.StubOutWithMock(server, 'keystone') self.m.StubOutWithMock(server, 'heat') self.m.StubOutWithMock(server, '_get_deployments_metadata') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) server.keystone().MultipleTimes().AndReturn(self.fkc) server.heat().MultipleTimes().AndReturn(self.fc) server._get_deployments_metadata( self.fc, 5678).AndReturn({'foo': 'bar'}) server.t = server.stack.resolve_runtime_data(server.t) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata=mox.IgnoreArg(), scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn( return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.assertEqual('4567', server.access_key) self.assertEqual('8901', server.secret_key) self.assertEqual('1234', server._get_user_id()) self.assertTrue(stack.access_allowed('4567', 'WebServer')) self.assertFalse(stack.access_allowed('45678', 'WebServer')) self.assertFalse(stack.access_allowed('4567', 'wWebServer')) self.assertEqual({ 'os-collect-config': { 'cfn': { 'access_key_id': '4567', 'metadata_url': '/v1/', 'path': 'WebServer.Metadata', 'secret_access_key': '8901', 'stack_name': 'software_config_s' } }, 'deployments': {'foo': 'bar'} }, server.metadata) created_server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.assertEqual('4567', created_server.access_key) self.assertTrue(stack.access_allowed('4567', 'WebServer')) self.m.VerifyAll() def test_server_create_software_config_poll_heat(self): return_server = self.fc.servers.list()[1] stack_name = 'software_config_s' (t, stack) = self._setup_test_stack(stack_name) props = t['Resources']['WebServer']['Properties'] props['user_data_format'] = 'SOFTWARE_CONFIG' props['software_config_transport'] = 'POLL_SERVER_HEAT' server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') self.m.StubOutWithMock(server, 'keystone') self.m.StubOutWithMock(server, 'heat') self.m.StubOutWithMock(server, '_get_deployments_metadata') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) server.keystone().MultipleTimes().AndReturn(self.fkc) server.heat().MultipleTimes().AndReturn(self.fc) server._get_deployments_metadata( self.fc, 5678).AndReturn({'foo': 'bar'}) server.t = server.stack.resolve_runtime_data(server.t) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata=mox.IgnoreArg(), scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn( return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() #self.assertEqual('4567', server.access_key) #self.assertEqual('8901', server.secret_key) self.assertEqual('1234', server._get_user_id()) self.assertTrue(stack.access_allowed('1234', 'WebServer')) self.assertFalse(stack.access_allowed('45678', 'WebServer')) self.assertFalse(stack.access_allowed('4567', 'wWebServer')) self.assertEqual({ 'os-collect-config': { 'heat': { 'auth_url': 'http://server.test:5000/v2.0', 'password': None, 'project_id': '8888', 'resource_name': 'WebServer', 'stack_id': 'software_config_s/%s' % stack.id, 'user_id': '1234' } }, 'deployments': {'foo': 'bar'} }, server.metadata) created_server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.assertEqual('1234', created_server._get_user_id()) self.assertTrue(stack.access_allowed('1234', 'WebServer')) self.m.VerifyAll() def test_server_metadata_with_empty_deploy(self): stack_name = 'software_config_s' (t, stack) = self._setup_test_stack(stack_name) props = t['Resources']['WebServer']['Properties'] props['user_data_format'] = 'SOFTWARE_CONFIG' server = servers.Server('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'keystone') server.t = server.stack.resolve_runtime_data(server.t) self.m.ReplayAll() deployments = server.metadata['deployments'] self.assertEqual([], deployments) self.m.VerifyAll() @mock.patch.object(clients.OpenStackClients, 'nova') def test_server_create_default_admin_pass(self, mock_nova): return_server = self.fc.servers.list()[1] return_server.adminPass = 'autogenerated' stack_name = 'admin_pass_s' (t, stack) = self._setup_test_stack(stack_name) server = servers.Server('WebServer', t['Resources']['WebServer'], stack) mock_nova.return_value = self.fc server.t = server.stack.resolve_runtime_data(server.t) self.fc.servers.create = mock.Mock(return_value=return_server) scheduler.TaskRunner(server.create)() self.fc.servers.create.assert_called_once_with( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata=mock.ANY, scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None) @mock.patch.object(clients.OpenStackClients, 'nova') def test_server_create_custom_admin_pass(self, mock_nova): return_server = self.fc.servers.list()[1] return_server.adminPass = 'foo' stack_name = 'admin_pass_s' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['admin_pass'] = 'foo' server = servers.Server('WebServer', t['Resources']['WebServer'], stack) mock_nova.return_value = self.fc server.t = server.stack.resolve_runtime_data(server.t) self.fc.servers.create = mock.Mock(return_value=return_server) scheduler.TaskRunner(server.create)() self.fc.servers.create.assert_called_once_with( image=744, flavor=3, key_name='test', name=utils.PhysName(stack_name, server.name), security_groups=[], userdata=mock.ANY, scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass='foo') def test_check_maximum(self): msg = 'test_check_maximum' self.assertIsNone(servers.Server._check_maximum(1, 1, msg)) self.assertIsNone(servers.Server._check_maximum(1000, -1, msg)) error = self.assertRaises(exception.StackValidationFailed, servers.Server._check_maximum, 2, 1, msg) self.assertEqual(msg, str(error)) def test_server_validate(self): stack_name = 'srv_val' (t, stack) = self._setup_test_stack(stack_name) # create an server with non exist image Id t['Resources']['WebServer']['Properties']['image'] = '1' server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_server_validate_with_bootable_vol(self): stack_name = 'srv_val_bootvol' (t, stack) = self._setup_test_stack(stack_name) # create an server with bootable volume web_server = t['Resources']['WebServer'] del web_server['Properties']['image'] def create_server(device_name): self.m.UnsetStubs() web_server['Properties']['block_device_mapping'] = [{ "device_name": device_name, "volume_id": "5d7e27da-6703-4f7e-9f94-1f67abef734c", "delete_on_termination": False }] server = servers.Server('server_with_bootable_volume', web_server, stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() return server server = create_server(u'vda') self.assertIsNone(server.validate()) server = create_server('vda') self.assertIsNone(server.validate()) server = create_server('vdb') ex = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual('Neither image nor bootable volume is specified for ' 'instance server_with_bootable_volume', str(ex)) self.m.VerifyAll() def test_server_validate_with_nova_keypair_resource(self): stack_name = 'srv_val_test' nova_keypair_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Resources" : { "WebServer": { "Type": "OS::Nova::Server", "Properties": { "image" : "F17-x86_64-gold", "flavor" : "m1.large", "key_name" : { "Ref": "SSHKey" }, "user_data" : "wordpress" } }, "SSHKey": { "Type": "OS::Nova::KeyPair", "Properties": { "name": "my_key" } } } } ''' t = template_format.parse(nova_keypair_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, stack_id=str(uuid.uuid4())) server = servers.Server('server_validate_test', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_server_validate_with_invalid_ssh_key(self): stack_name = 'srv_val_test' (t, stack) = self._setup_test_stack(stack_name) web_server = t['Resources']['WebServer'] # Make the ssh key have an invalid name web_server['Properties']['key_name'] = 'test2' server = servers.Server('server_validate_test', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual( 'Property error : server_validate_test: key_name "test2" does ' 'not validate nova.keypair', str(error)) self.m.VerifyAll() def test_server_validate_delete_policy(self): stack_name = 'srv_val_delpol' (t, stack) = self._setup_test_stack(stack_name) # create an server with non exist image Id t['Resources']['WebServer']['DeletionPolicy'] = 'SelfDestruct' server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.ReplayAll() ex = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual('Invalid DeletionPolicy SelfDestruct', str(ex)) self.m.VerifyAll() def test_server_validate_with_networks(self): stack_name = 'srv_net' (t, stack) = self._setup_test_stack(stack_name) network_name = 'public' # create an server with 'uuid' and 'network' properties t['Resources']['WebServer']['Properties']['networks'] = ( [{'uuid': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'network': network_name}]) server = servers.Server('server_validate_with_networks', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() ex = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertIn(_('Properties "uuid" and "network" are both set to ' 'the network "%(network)s" for the server ' '"%(server)s". The "uuid" property is deprecated. ' 'Use only "network" property.' '') % dict(network=network_name, server=server.name), str(ex)) self.m.VerifyAll() def test_server_validate_net_security_groups(self): # Test that if network 'ports' are assigned security groups are # not, because they'll be ignored stack_name = 'srv_net_secgroups' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['networks'] = [ {'port': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}] t['Resources']['WebServer']['Properties']['security_groups'] = \ ['my_security_group'] server = servers.Server('server_validate_net_security_groups', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() error = self.assertRaises(exception.ResourcePropertyConflict, server.validate) self.assertEqual("Cannot define the following properties at the same " "time: security_groups, networks/port.", str(error)) self.m.VerifyAll() def test_server_delete(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'create_delete') server.resource_id = 1234 # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) server_get = self.fc.client.get_servers_1234() self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn(server_get) get().AndRaise(servers.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) self.m.ReplayAll() scheduler.TaskRunner(server.delete)() self.assertIsNone(server.resource_id) self.assertEqual((server.DELETE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_delete_notfound(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'create_delete2') server.resource_id = 1234 # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(servers.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) scheduler.TaskRunner(server.delete)() self.assertIsNone(server.resource_id) self.assertEqual((server.DELETE, server.COMPLETE), server.state) self.m.VerifyAll() server.state_set(server.CREATE, server.COMPLETE, 'to delete again') scheduler.TaskRunner(server.delete)() self.assertEqual((server.DELETE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_metadata(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'md_update') update_template = copy.deepcopy(server.t) update_template['Metadata'] = {'test': 123} scheduler.TaskRunner(server.update, update_template)() self.assertEqual({'test': 123}, server.metadata) server.t['Metadata'] = {'test': 456} server.metadata_update() self.assertEqual({'test': 456}, server.metadata) def test_server_update_nova_metadata(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'md_update') new_meta = {'test': 123} self.m.StubOutWithMock(self.fc.servers, 'set_meta') self.fc.servers.set_meta(return_server, nova_utils.meta_serialize( new_meta)).AndReturn(None) self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_nova_metadata_complex(self): """ Test that complex metadata values are correctly serialized to JSON when sent to Nova. """ return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'md_update') new_meta = {'test': {'testkey': 'testvalue'}} self.m.StubOutWithMock(self.fc.servers, 'set_meta') # If we're going to call set_meta() directly we # need to handle the serialization ourselves. self.fc.servers.set_meta(return_server, nova_utils.meta_serialize( new_meta)).AndReturn(None) self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_nova_metadata_with_delete(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'md_update') # part one, add some metadata new_meta = {'test': '123', 'this': 'that'} self.m.StubOutWithMock(self.fc.servers, 'set_meta') self.fc.servers.set_meta(return_server, new_meta).AndReturn(None) self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() self.m.UnsetStubs() # part two change the metadata (test removing the old key) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() new_meta = {'new_key': 'yeah'} self.m.StubOutWithMock(self.fc.servers, 'delete_meta') new_return_server = self.fc.servers.list()[5] self.fc.servers.delete_meta(new_return_server, ['test', 'this']).AndReturn(None) self.m.StubOutWithMock(self.fc.servers, 'set_meta') self.fc.servers.set_meta(new_return_server, new_meta).AndReturn(None) self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta # new fake with the correct metadata server.resource_id = '56789' scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_server_name(self): """ Server.handle_update supports changing the name. """ return_server = self.fc.servers.list()[1] return_server.id = 5678 server = self._create_test_server(return_server, 'srv_update') new_name = 'new_name' update_template = copy.deepcopy(server.t) update_template['Properties']['name'] = new_name self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(5678).AndReturn(return_server) self.m.StubOutWithMock(return_server, 'update') return_server.update(new_name).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_server_flavor(self): """ Server.handle_update supports changing the flavor, and makes the change making a resize API call against Nova. """ return_server = self.fc.servers.list()[1] return_server.id = 1234 server = self._create_test_server(return_server, 'srv_update') update_template = copy.deepcopy(server.t) update_template['Properties']['flavor'] = 'm1.small' self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(1234).AndReturn(return_server) def activate_status(server): server.status = 'VERIFY_RESIZE' return_server.get = activate_status.__get__(return_server) self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') self.fc.client.post_servers_1234_action( body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) self.fc.client.post_servers_1234_action( body={'confirmResize': None}).AndReturn((202, None)) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_server_flavor_failed(self): """ If the status after a resize is not VERIFY_RESIZE, it means the resize call failed, so we raise an explicit error. """ return_server = self.fc.servers.list()[1] return_server.id = 1234 server = self._create_test_server(return_server, 'srv_update2') update_template = copy.deepcopy(server.t) update_template['Properties']['flavor'] = 'm1.small' self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(1234).AndReturn(return_server) def activate_status(server): server.status = 'ACTIVE' return_server.get = activate_status.__get__(return_server) self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') self.fc.client.post_servers_1234_action( body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) self.m.ReplayAll() updater = scheduler.TaskRunner(server.update, update_template) error = self.assertRaises(exception.ResourceFailure, updater) self.assertEqual( "Error: Resizing to 'm1.small' failed, status 'ACTIVE'", str(error)) self.assertEqual((server.UPDATE, server.FAILED), server.state) self.m.VerifyAll() def test_server_update_server_flavor_replace(self): stack_name = 'update_flvrep' (t, stack) = self._setup_test_stack(stack_name) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() t['Resources']['WebServer']['Properties'][ 'flavor_update_policy'] = 'REPLACE' server = servers.Server('server_server_update_flavor_replace', t['Resources']['WebServer'], stack) update_template = copy.deepcopy(server.t) update_template['Properties']['flavor'] = 'm1.smigish' updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def test_server_update_server_flavor_policy_update(self): stack_name = 'update_flvpol' (t, stack) = self._setup_test_stack(stack_name) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() server = servers.Server('server_server_update_flavor_replace', t['Resources']['WebServer'], stack) update_template = copy.deepcopy(server.t) # confirm that when flavor_update_policy is changed during # the update then the updated policy is followed for a flavor # update update_template['Properties']['flavor_update_policy'] = 'REPLACE' update_template['Properties']['flavor'] = 'm1.smigish' updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def test_server_update_image_replace(self): stack_name = 'update_imgrep' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties'][ 'image_update_policy'] = 'REPLACE' server = servers.Server('server_update_image_replace', t['Resources']['WebServer'], stack) image_id = self.getUniqueString() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = image_id updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def _test_server_update_image_rebuild(self, status, policy='REBUILD'): # Server.handle_update supports changing the image, and makes # the change making a rebuild API call against Nova. return_server = self.fc.servers.list()[1] return_server.id = 1234 server = self._create_test_server(return_server, 'srv_updimgrbld') new_image = 'F17-x86_64-gold' update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = new_image server.t['Properties']['image_update_policy'] = policy self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(1234).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(self.fc.servers, 'rebuild') # 744 is a static lookup from the fake images list if 'REBUILD' == policy: self.fc.servers.rebuild( return_server, 744, password=None, preserve_ephemeral=False) else: self.fc.servers.rebuild( return_server, 744, password=None, preserve_ephemeral=True) self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') for stat in status: def activate_status(serv): serv.status = stat return_server.get = activate_status.__get__(return_server) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_image_rebuild_status_rebuild(self): # Normally we will see 'REBUILD' first and then 'ACTIVE". self._test_server_update_image_rebuild(status=('REBUILD', 'ACTIVE')) def test_server_update_image_rebuild_status_active(self): # It is possible for us to miss the REBUILD status. self._test_server_update_image_rebuild(status=('ACTIVE',)) def test_server_update_image_rebuild_status_rebuild_keep_ephemeral(self): # Normally we will see 'REBUILD' first and then 'ACTIVE". self._test_server_update_image_rebuild( policy='REBUILD_PRESERVE_EPHEMERAL', status=('REBUILD', 'ACTIVE')) def test_server_update_image_rebuild_status_active_keep_ephemeral(self): # It is possible for us to miss the REBUILD status. self._test_server_update_image_rebuild( policy='REBUILD_PRESERVE_EPHEMERAL', status=('ACTIVE')) def test_server_update_image_rebuild_failed(self): # If the status after a rebuild is not REBUILD or ACTIVE, it means the # rebuild call failed, so we raise an explicit error. return_server = self.fc.servers.list()[1] return_server.id = 1234 server = self._create_test_server(return_server, 'srv_updrbldfail') new_image = 'F17-x86_64-gold' update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = new_image server.t['Properties']['image_update_policy'] = 'REBUILD' self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(1234).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(self.fc.servers, 'rebuild') # 744 is a static lookup from the fake images list self.fc.servers.rebuild( return_server, 744, password=None, preserve_ephemeral=False) self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') def activate_status(server): server.status = 'REBUILD' return_server.get = activate_status.__get__(return_server) def activate_status2(server): server.status = 'ERROR' return_server.get = activate_status2.__get__(return_server) self.m.ReplayAll() updater = scheduler.TaskRunner(server.update, update_template) error = self.assertRaises(exception.ResourceFailure, updater) self.assertEqual( "Error: Rebuilding server failed, status 'ERROR'", str(error)) self.assertEqual((server.UPDATE, server.FAILED), server.state) self.m.VerifyAll() def test_server_update_attr_replace(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'update_rep') update_template = copy.deepcopy(server.t) update_template['UpdatePolicy'] = {'test': 123} updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def test_server_update_properties(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'update_prop') self.m.StubOutWithMock(image.ImageConstraint, "validate") image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = 'mustreplace' updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(resource.UpdateReplace, updater) def test_server_status_build(self): return_server = self.fc.servers.list()[0] server = self._setup_test_server(return_server, 'sts_build') server.resource_id = 1234 # Bind fake get method which Server.check_create_complete will call def activate_status(server): server.status = 'ACTIVE' return_server.get = activate_status.__get__(return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) def test_server_status_suspend_no_resource_id(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_sus1') server.resource_id = None self.m.ReplayAll() ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.suspend)) self.assertEqual('Error: Cannot suspend srv_sus1, ' 'resource_id not set', str(ex)) self.assertEqual((server.SUSPEND, server.FAILED), server.state) self.m.VerifyAll() def test_server_status_suspend_not_found(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_sus2') server.resource_id = 1234 self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(servers.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) self.m.ReplayAll() ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.suspend)) self.assertEqual('NotFound: Failed to find server 1234', str(ex)) self.assertEqual((server.SUSPEND, server.FAILED), server.state) self.m.VerifyAll() def test_server_status_suspend_immediate(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_suspend3') server.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d['server']['status'] = 'SUSPENDED' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d)) mox.Replay(get) scheduler.TaskRunner(server.suspend)() self.assertEqual((server.SUSPEND, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_status_resume_immediate(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_resume1') server.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d['server']['status'] = 'ACTIVE' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d)) mox.Replay(get) server.state_set(server.SUSPEND, server.COMPLETE) scheduler.TaskRunner(server.resume)() self.assertEqual((server.RESUME, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_status_suspend_wait(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_susp_w') server.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED, but # return the ACTIVE state first (twice, so we sleep) d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d2 = copy.deepcopy(d1) d1['server']['status'] = 'ACTIVE' d2['server']['status'] = 'SUSPENDED' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d1)) get().AndReturn((200, d1)) get().AndReturn((200, d2)) self.m.ReplayAll() scheduler.TaskRunner(server.suspend)() self.assertEqual((server.SUSPEND, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_status_suspend_unknown_status(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_susp_uk') server.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to SUSPENDED, but # return the ACTIVE state first (twice, so we sleep) d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d2 = copy.deepcopy(d1) d1['server']['status'] = 'ACTIVE' d2['server']['status'] = 'TRANSMOGRIFIED' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d1)) get().AndReturn((200, d1)) get().AndReturn((200, d2)) self.m.ReplayAll() ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.suspend)) self.assertEqual('Error: Suspend of server sample-server failed ' 'with unknown status: TRANSMOGRIFIED', str(ex)) self.assertEqual((server.SUSPEND, server.FAILED), server.state) self.m.VerifyAll() def test_server_status_resume_wait(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_res_w') server.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to ACTIVE, but # return the SUSPENDED state first (twice, so we sleep) d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]} d2 = copy.deepcopy(d1) d1['server']['status'] = 'SUSPENDED' d2['server']['status'] = 'ACTIVE' self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndReturn((200, d1)) get().AndReturn((200, d1)) get().AndReturn((200, d2)) self.m.ReplayAll() server.state_set(server.SUSPEND, server.COMPLETE) scheduler.TaskRunner(server.resume)() self.assertEqual((server.RESUME, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_status_resume_no_resource_id(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_susp_norid') server.resource_id = None self.m.ReplayAll() server.state_set(server.SUSPEND, server.COMPLETE) ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.resume)) self.assertEqual('Error: Cannot resume srv_susp_norid, ' 'resource_id not set', str(ex)) self.assertEqual((server.RESUME, server.FAILED), server.state) self.m.VerifyAll() def test_server_status_resume_not_found(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_res_nf') server.resource_id = 1234 self.m.ReplayAll() # Override the get_servers_1234 handler status to ACTIVE, but # return the SUSPENDED state first (twice, so we sleep) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(servers.clients.novaclient.exceptions.NotFound(404)) self.m.ReplayAll() server.state_set(server.SUSPEND, server.COMPLETE) ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.resume)) self.assertEqual('NotFound: Failed to find server 1234', str(ex)) self.assertEqual((server.RESUME, server.FAILED), server.state) self.m.VerifyAll() def test_server_status_build_spawning(self): self._test_server_status_not_build_active('BUILD(SPAWNING)') def test_server_status_hard_reboot(self): self._test_server_status_not_build_active('HARD_REBOOT') def test_server_status_password(self): self._test_server_status_not_build_active('PASSWORD') def test_server_status_reboot(self): self._test_server_status_not_build_active('REBOOT') def test_server_status_rescue(self): self._test_server_status_not_build_active('RESCUE') def test_server_status_resize(self): self._test_server_status_not_build_active('RESIZE') def test_server_status_revert_resize(self): self._test_server_status_not_build_active('REVERT_RESIZE') def test_server_status_shutoff(self): self._test_server_status_not_build_active('SHUTOFF') def test_server_status_suspended(self): self._test_server_status_not_build_active('SUSPENDED') def test_server_status_verify_resize(self): self._test_server_status_not_build_active('VERIFY_RESIZE') def _test_server_status_not_build_active(self, uncommon_status): return_server = self.fc.servers.list()[0] server = self._setup_test_server(return_server, 'srv_sts_bld') server.resource_id = 1234 check_iterations = [0] # Bind fake get method which Server.check_create_complete will call def activate_status(server): check_iterations[0] += 1 if check_iterations[0] == 1: server.status = uncommon_status if check_iterations[0] > 2: server.status = 'ACTIVE' return_server.get = activate_status.__get__(return_server) self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_build_nics(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'test_server_create') self.assertIsNone(server._build_nics([])) self.assertIsNone(server._build_nics(None)) self.assertEqual([{'port-id': 'aaaabbbb'}, {'v4-fixed-ip': '192.0.2.0'}], server._build_nics([{'port': 'aaaabbbb'}, {'fixed_ip': '192.0.2.0'}])) self.assertEqual([{'net-id': '1234abcd'}], server._build_nics([{'uuid': '1234abcd'}])) self.assertEqual([{'net-id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}], server._build_nics( [{'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}] )) self.assertEqual([{'net-id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}], server._build_nics([{'network': 'public'}])) self.assertRaises(exceptions.NoUniqueMatch, server._build_nics, ([{'network': 'foo'}])) self.assertRaises(exceptions.NotFound, server._build_nics, ([{'network': 'bar'}])) def test_server_without_ip_address(self): return_server = self.fc.servers.list()[3] return_server.id = 9102 server = self._create_test_server(return_server, 'wo_ipaddr') self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(9102).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(return_server, 'interface_list') return_server.interface_list().MultipleTimes().AndReturn([]) self.m.ReplayAll() self.assertEqual({'empty_net': []}, server.FnGetAtt('addresses')) self.assertEqual({'empty_net': []}, server.FnGetAtt('networks')) self.assertEqual('', server.FnGetAtt('first_address')) self.m.VerifyAll() def test_build_block_device_mapping(self): self.assertIsNone(servers.Server._build_block_device_mapping([])) self.assertIsNone(servers.Server._build_block_device_mapping(None)) self.assertEqual({ 'vda': '1234:', 'vdb': '1234:snap', }, servers.Server._build_block_device_mapping([ {'device_name': 'vda', 'volume_id': '1234'}, {'device_name': 'vdb', 'snapshot_id': '1234'}, ])) self.assertEqual({ 'vdc': '1234::10', 'vdd': '1234:snap:0:True' }, servers.Server._build_block_device_mapping([ { 'device_name': 'vdc', 'volume_id': '1234', 'volume_size': 10 }, { 'device_name': 'vdd', 'snapshot_id': '1234', 'delete_on_termination': True } ])) def test_validate_block_device_mapping_volume_size_valid_int(self): stack_name = 'val_vsize_valid' t, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', 'volume_size': 10}] t['Resources']['WebServer']['Properties']['block_device_mapping'] = bdm server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_validate_block_device_mapping_volume_size_valid_str(self): stack_name = 'val_vsize_valid' t, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', 'volume_size': '10'}] t['Resources']['WebServer']['Properties']['block_device_mapping'] = bdm server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_validate_block_device_mapping_volume_size_invalid_str(self): stack_name = 'val_vsize_invalid' t, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', 'volume_size': '10a'}] t['Resources']['WebServer']['Properties']['block_device_mapping'] = bdm server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) exc = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertIn("Value '10a' is not an integer", str(exc)) def test_validate_conflict_block_device_mapping_props(self): stack_name = 'val_blkdev1' (t, stack) = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vdb', 'snapshot_id': '1234', 'volume_id': '1234'}] t['Resources']['WebServer']['Properties']['block_device_mapping'] = bdm server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertRaises(exception.ResourcePropertyConflict, server.validate) self.m.VerifyAll() def test_validate_insufficient_block_device_mapping_props(self): stack_name = 'val_blkdev2' (t, stack) = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vdb', 'volume_size': 1, 'delete_on_termination': True}] t['Resources']['WebServer']['Properties']['block_device_mapping'] = bdm server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() ex = self.assertRaises(exception.StackValidationFailed, server.validate) msg = 'Either volume_id or snapshot_id must be specified for device' +\ ' mapping vdb' self.assertEqual(msg, str(ex)) self.m.VerifyAll() def test_validate_without_image_or_bootable_volume(self): stack_name = 'val_imgvol' (t, stack) = self._setup_test_stack(stack_name) del t['Resources']['WebServer']['Properties']['image'] bdm = [{'device_name': 'vdb', 'volume_id': '1234'}] t['Resources']['WebServer']['Properties']['block_device_mapping'] = bdm server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() ex = self.assertRaises(exception.StackValidationFailed, server.validate) msg = 'Neither image nor bootable volume is specified for instance %s'\ % server.name self.assertEqual(msg, str(ex)) self.m.VerifyAll() def test_validate_metadata_too_many(self): stack_name = 'srv_val_metadata' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['metadata'] = {'a': 1, 'b': 2, 'c': 3, 'd': 4} server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(self.fc.limits, 'get') self.fc.limits.get().MultipleTimes().AndReturn(self.limits) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() ex = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertIn('Instance metadata must not contain greater than 3 ' 'entries', str(ex)) self.m.VerifyAll() def test_validate_metadata_okay(self): stack_name = 'srv_val_metadata' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['metadata'] = {'a': 1, 'b': 2, 'c': 3} server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(self.fc.limits, 'get') self.fc.limits.get().MultipleTimes().AndReturn(self.limits) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_server_validate_too_many_personality(self): stack_name = 'srv_val' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['personality'] = \ {"/fake/path1": "fake contents1", "/fake/path2": "fake_contents2", "/fake/path3": "fake_contents3", "/fake/path4": "fake_contents4", "/fake/path5": "fake_contents5", "/fake/path6": "fake_contents6"} server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(self.fc.limits, 'get') self.fc.limits.get().MultipleTimes().AndReturn(self.limits) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() exc = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual("The personality property may not contain " "greater than 5 entries.", str(exc)) self.m.VerifyAll() def test_server_validate_personality_okay(self): stack_name = 'srv_val' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['personality'] = \ {"/fake/path1": "fake contents1", "/fake/path2": "fake_contents2", "/fake/path3": "fake_contents3", "/fake/path4": "fake_contents4", "/fake/path5": "fake_contents5"} server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(self.fc.limits, 'get') self.fc.limits.get().MultipleTimes().AndReturn(self.limits) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_server_validate_personality_file_size_okay(self): stack_name = 'srv_val' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['personality'] = \ {"/fake/path1": "a" * 10240} server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(self.fc.limits, 'get') self.fc.limits.get().MultipleTimes().AndReturn(self.limits) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() self.assertIsNone(server.validate()) self.m.VerifyAll() def test_server_validate_personality_file_size_too_big(self): stack_name = 'srv_val' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['personality'] = \ {"/fake/path1": "a" * 10241} server = servers.Server('server_create_image_err', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(self.fc.limits, 'get') self.fc.limits.get().MultipleTimes().AndReturn(self.limits) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() exc = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual("The contents of personality file \"/fake/path1\" " "is larger than the maximum allowed personality " "file size (10240 bytes).", str(exc)) self.m.VerifyAll() def test_resolve_attribute_server_not_found(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_resolve_attr') server.resource_id = 1234 self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(servers.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) self.m.ReplayAll() self.assertEqual(server._resolve_attribute("accessIPv4"), '') self.m.VerifyAll() def test_default_instance_user(self): """The default value for instance_user in heat.conf is ec2-user.""" return_server = self.fc.servers.list()[1] server = self._setup_test_server(return_server, 'default_user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(server, 'wordpress', instance_user='ec2-user', user_data_format='HEAT_CFNTOOLS') self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_admin_user_property(self): """Test the admin_user property on the server overrides instance_user. Launching the instance should call build_userdata with the custom user name. This property is deprecated and will be removed in Juno. """ return_server = self.fc.servers.list()[1] stack_name = 'stack_with_custom_admin_user_server' (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['admin_user'] = 'custom_user' server = servers.Server('create_metadata_test_server', t['Resources']['WebServer'], stack) server.t = server.stack.resolve_runtime_data(server.t) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=mox.IgnoreArg(), flavor=mox.IgnoreArg(), key_name='test', name=mox.IgnoreArg(), security_groups=[], userdata=mox.IgnoreArg(), scheduler_hints=None, meta=mox.IgnoreArg(), nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None, files={}, admin_pass=None).AndReturn(return_server) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(server, 'wordpress', instance_user='custom_user', user_data_format='HEAT_CFNTOOLS') self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_custom_instance_user(self): """Test instance_user in heat.conf being set to a custom value. Launching the instance should call build_userdata with the custom user name. This option is deprecated and will be removed in Juno. """ return_server = self.fc.servers.list()[1] server = self._setup_test_server(return_server, 'custom_user') self.m.StubOutWithMock(servers.cfg.CONF, 'instance_user') servers.cfg.CONF.instance_user = 'custom_user' self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(server, 'wordpress', instance_user='custom_user', user_data_format='HEAT_CFNTOOLS') self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def test_empty_instance_user(self): """Test instance_user in heat.conf being empty. Launching the instance should not pass any user to build_userdata. The default cloud-init user set up for the image will be used instead. This will the default behaviour in Juno once we remove the instance_user option. """ return_server = self.fc.servers.list()[1] server = self._setup_test_server(return_server, 'custom_user') self.m.StubOutWithMock(servers.cfg.CONF, 'instance_user') servers.cfg.CONF.instance_user = '' self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(server, 'wordpress', instance_user=None, user_data_format='HEAT_CFNTOOLS') self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.m.VerifyAll() def create_old_net(self, port=None, net=None, ip=None): return {'port': port, 'network': net, 'fixed_ip': ip, 'uuid': None} def create_fake_iface(self, port, net, ip): class fake_interface(): def __init__(self, port_id, net_id, fixed_ip): self.port_id = port_id self.net_id = net_id self.fixed_ips = [{'ip_address': fixed_ip}] return fake_interface(port, net, ip) def test_get_network_matches_no_matching(self): return_server = self.fc.servers.list()[3] server = self._create_test_server(return_server, 'networks_update') for new_nets in ([], [{'port': '952fd4ae-53b9-4b39-9e5f-8929c553b5ae'}]): old_nets = [ self.create_old_net( port='2a60cbaa-3d33-4af6-a9ce-83594ac546fc'), self.create_old_net( net='f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', ip='1.2.3.4'), self.create_old_net( net='0da8adbf-a7e2-4c59-a511-96b03d2da0d7')] new_nets_copy = copy.deepcopy(new_nets) old_nets_copy = copy.deepcopy(old_nets) for net in old_nets_copy: net.pop('uuid') for net in new_nets_copy: for key in ('port', 'network', 'fixed_ip'): net[key] = net.get(key) matched_nets = server._get_network_matches(old_nets, new_nets) self.assertEqual([], matched_nets) self.assertEqual(old_nets_copy, old_nets) self.assertEqual(new_nets_copy, new_nets) def test_get_network_matches_success(self): return_server = self.fc.servers.list()[3] server = self._create_test_server(return_server, 'networks_update') old_nets = [ self.create_old_net( port='2a60cbaa-3d33-4af6-a9ce-83594ac546fc'), self.create_old_net( net='f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', ip='1.2.3.4'), self.create_old_net( net='0da8adbf-a7e2-4c59-a511-96b03d2da0d7')] new_nets = [ {'port': '2a60cbaa-3d33-4af6-a9ce-83594ac546fc'}, {'network': 'f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', 'fixed_ip': '1.2.3.4'}, {'port': '952fd4ae-53b9-4b39-9e5f-8929c553b5ae'}] new_nets_copy = copy.deepcopy(new_nets) old_nets_copy = copy.deepcopy(old_nets) for net in old_nets_copy: net.pop('uuid') for net in new_nets_copy: for key in ('port', 'network', 'fixed_ip'): net[key] = net.get(key) matched_nets = server._get_network_matches(old_nets, new_nets) self.assertEqual(old_nets_copy[:-1], matched_nets) self.assertEqual([old_nets_copy[2]], old_nets) self.assertEqual([new_nets_copy[2]], new_nets) def test_update_networks_matching_iface_port(self): return_server = self.fc.servers.list()[3] server = self._create_test_server(return_server, 'networks_update') # old order 0 1 2 3 4 5 nets = [ {'port': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'network': None, 'fixed_ip': None}, {'port': None, 'network': 'gggggggg-1111-1111-1111-gggggggggggg', 'fixed_ip': '1.2.3.4', }, {'port': None, 'network': 'f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', 'fixed_ip': None}, {'port': 'dddddddd-dddd-dddd-dddd-dddddddddddd', 'network': None, 'fixed_ip': None}, {'port': None, 'network': 'gggggggg-1111-1111-1111-gggggggggggg', 'fixed_ip': '5.6.7.8'}, {'port': None, 'network': '0da8adbf-a7e2-4c59-a511-96b03d2da0d7', 'fixed_ip': None}] # new order 5 2 3 0 1 4 interfaces = [ self.create_fake_iface('ffffffff-ffff-ffff-ffff-ffffffffffff', nets[5]['network'], '10.0.0.10'), self.create_fake_iface('cccccccc-cccc-cccc-cccc-cccccccccccc', nets[2]['network'], '10.0.0.11'), self.create_fake_iface(nets[3]['port'], 'f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', '10.0.0.12'), self.create_fake_iface(nets[0]['port'], 'gggggggg-1111-1111-1111-gggggggggggg', '10.0.0.13'), self.create_fake_iface('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', nets[1]['network'], nets[1]['fixed_ip']), self.create_fake_iface('eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee', nets[4]['network'], nets[4]['fixed_ip'])] # all networks should get port id expected = [ {'port': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'network': None, 'fixed_ip': None}, {'port': 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'network': 'gggggggg-1111-1111-1111-gggggggggggg', 'fixed_ip': '1.2.3.4'}, {'port': 'cccccccc-cccc-cccc-cccc-cccccccccccc', 'network': 'f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', 'fixed_ip': None}, {'port': 'dddddddd-dddd-dddd-dddd-dddddddddddd', 'network': None, 'fixed_ip': None}, {'port': 'eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee', 'network': 'gggggggg-1111-1111-1111-gggggggggggg', 'fixed_ip': '5.6.7.8'}, {'port': 'ffffffff-ffff-ffff-ffff-ffffffffffff', 'network': '0da8adbf-a7e2-4c59-a511-96b03d2da0d7', 'fixed_ip': None}] server.update_networks_matching_iface_port(nets, interfaces) self.assertEqual(expected, nets) def test_server_update_None_networks_with_port(self): return_server = self.fc.servers.list()[3] return_server.id = 9102 server = self._create_test_server(return_server, 'networks_update') new_networks = [{'port': '2a60cbaa-3d33-4af6-a9ce-83594ac546fc'}] update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(9102).MultipleTimes().AndReturn(return_server) # to make sure, that old_networks will be None self.assertFalse(hasattr(server.t['Properties'], 'networks')) iface = self.create_fake_iface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', '1.2.3.4') self.m.StubOutWithMock(return_server, 'interface_list') return_server.interface_list().AndReturn([iface]) self.m.StubOutWithMock(return_server, 'interface_detach') return_server.interface_detach( 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa').AndReturn(None) self.m.StubOutWithMock(return_server, 'interface_attach') return_server.interface_attach(new_networks[0]['port'], None, None).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_None_networks_with_network_id(self): return_server = self.fc.servers.list()[3] return_server.id = 9102 server = self._create_test_server(return_server, 'networks_update') new_networks = [{'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '1.2.3.4'}] update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(9102).MultipleTimes().AndReturn(return_server) # to make sure, that old_networks will be None self.assertFalse(hasattr(server.t['Properties'], 'networks')) iface = self.create_fake_iface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', '1.2.3.4') self.m.StubOutWithMock(return_server, 'interface_list') return_server.interface_list().AndReturn([iface]) self.m.StubOutWithMock(return_server, 'interface_detach') return_server.interface_detach( 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa').AndReturn(None) self.m.StubOutWithMock(return_server, 'interface_attach') return_server.interface_attach(None, new_networks[0]['network'], new_networks[0]['fixed_ip']).AndReturn( None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_empty_networks_with_complex_parameters(self): return_server = self.fc.servers.list()[3] return_server.id = 9102 server = self._create_test_server(return_server, 'networks_update') new_networks = [{'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '1.2.3.4', 'port': '2a60cbaa-3d33-4af6-a9ce-83594ac546fc'}] update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(9102).MultipleTimes().AndReturn(return_server) # to make sure, that old_networks will be None self.assertFalse(hasattr(server.t['Properties'], 'networks')) iface = self.create_fake_iface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', '1.2.3.4') self.m.StubOutWithMock(return_server, 'interface_list') return_server.interface_list().AndReturn([iface]) self.m.StubOutWithMock(return_server, 'interface_detach') return_server.interface_detach( 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa').AndReturn(None) self.m.StubOutWithMock(return_server, 'interface_attach') return_server.interface_attach( new_networks[0]['port'], None, None).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_networks_with_complex_parameters(self): return_server = self.fc.servers.list()[1] return_server.id = 5678 server = self._create_test_server(return_server, 'networks_update') old_networks = [ {'port': '95e25541-d26a-478d-8f36-ae1c8f6b74dc'}, {'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '1.2.3.4'}, {'port': '4121f61a-1b2e-4ab0-901e-eade9b1cb09d'}, {'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '31.32.33.34'}] new_networks = [ {'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '1.2.3.4'}, {'port': '2a60cbaa-3d33-4af6-a9ce-83594ac546fc'}] server.t['Properties']['networks'] = old_networks update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(5678).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(return_server, 'interface_list') poor_interfaces = [ self.create_fake_iface('95e25541-d26a-478d-8f36-ae1c8f6b74dc', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '11.12.13.14'), self.create_fake_iface('450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '1.2.3.4'), self.create_fake_iface('4121f61a-1b2e-4ab0-901e-eade9b1cb09d', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '21.22.23.24'), self.create_fake_iface('0907fa82-a024-43c2-9fc5-efa1bccaa74a', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '31.32.33.34') ] return_server.interface_list().AndReturn(poor_interfaces) self.m.StubOutWithMock(return_server, 'interface_detach') return_server.interface_detach( poor_interfaces[0].port_id).InAnyOrder().AndReturn(None) return_server.interface_detach( poor_interfaces[2].port_id).InAnyOrder().AndReturn(None) return_server.interface_detach( poor_interfaces[3].port_id).InAnyOrder().AndReturn(None) self.m.StubOutWithMock(return_server, 'interface_attach') return_server.interface_attach( new_networks[1]['port'], None, None).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_networks_with_None(self): return_server = self.fc.servers.list()[1] return_server.id = 5678 server = self._create_test_server(return_server, 'networks_update') old_networks = [ {'port': '95e25541-d26a-478d-8f36-ae1c8f6b74dc'}, {'port': '4121f61a-1b2e-4ab0-901e-eade9b1cb09d'}, {'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '31.32.33.34'}] server.t['Properties']['networks'] = old_networks update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = None self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(5678).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(return_server, 'interface_list') poor_interfaces = [ self.create_fake_iface('95e25541-d26a-478d-8f36-ae1c8f6b74dc', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '11.12.13.14'), self.create_fake_iface('4121f61a-1b2e-4ab0-901e-eade9b1cb09d', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '21.22.23.24'), self.create_fake_iface('0907fa82-a024-43c2-9fc5-efa1bccaa74a', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '31.32.33.34') ] return_server.interface_list().AndReturn(poor_interfaces) self.m.StubOutWithMock(return_server, 'interface_detach') return_server.interface_detach( poor_interfaces[0].port_id).InAnyOrder().AndReturn(None) return_server.interface_detach( poor_interfaces[1].port_id).InAnyOrder().AndReturn(None) return_server.interface_detach( poor_interfaces[2].port_id).InAnyOrder().AndReturn(None) self.m.StubOutWithMock(return_server, 'interface_attach') return_server.interface_attach(None, None, None).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_update_networks_with_empty_list(self): return_server = self.fc.servers.list()[1] return_server.id = 5678 server = self._create_test_server(return_server, 'networks_update') old_networks = [ {'port': '95e25541-d26a-478d-8f36-ae1c8f6b74dc'}, {'port': '4121f61a-1b2e-4ab0-901e-eade9b1cb09d'}, {'network': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '31.32.33.34'}] server.t['Properties']['networks'] = old_networks update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = [] self.m.StubOutWithMock(self.fc.servers, 'get') self.fc.servers.get(5678).MultipleTimes().AndReturn(return_server) self.m.StubOutWithMock(return_server, 'interface_list') poor_interfaces = [ self.create_fake_iface('95e25541-d26a-478d-8f36-ae1c8f6b74dc', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '11.12.13.14'), self.create_fake_iface('4121f61a-1b2e-4ab0-901e-eade9b1cb09d', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '21.22.23.24'), self.create_fake_iface('0907fa82-a024-43c2-9fc5-efa1bccaa74a', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '31.32.33.34') ] return_server.interface_list().AndReturn(poor_interfaces) self.m.StubOutWithMock(return_server, 'interface_detach') return_server.interface_detach( poor_interfaces[0].port_id).InAnyOrder().AndReturn(None) return_server.interface_detach( poor_interfaces[1].port_id).InAnyOrder().AndReturn(None) return_server.interface_detach( poor_interfaces[2].port_id).InAnyOrder().AndReturn(None) self.m.StubOutWithMock(return_server, 'interface_attach') return_server.interface_attach(None, None, None).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) self.m.VerifyAll() def test_server_dont_validate_personality_if_personality_isnt_set(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) server = servers.Server('server_create_image_err', tmpl['Resources']['WebServer'], stack) # We mock out nova_utils.absolute_limits but we don't specify # how this mock should behave, so mox will verify that this mock # is NOT called during call to server.validate(). # This is the way to validate that no excessive calls to Nova # are made during validation. self.m.StubOutWithMock(nova_utils, 'absolute_limits') self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() # Assert here checks that server resource validates, but actually # this call is Act stage of this test. We calling server.validate() # to verify that no excessive calls to Nova are made during validation. self.assertIsNone(server.validate()) self.m.VerifyAll() class FlavorConstraintTest(HeatTestCase): def test_validate(self): client = fakes.FakeClient() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(client) client.flavors = self.m.CreateMockAnything() flavor = collections.namedtuple("Flavor", ["id", "name"]) flavor.id = "1234" flavor.name = "foo" client.flavors.list().MultipleTimes().AndReturn([flavor]) self.m.ReplayAll() constraint = servers.FlavorConstraint() self.assertFalse(constraint.validate("bar", None)) self.assertTrue(constraint.validate("foo", None)) self.assertTrue(constraint.validate("1234", None)) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_autoscaling_update_policy.py0000664000567000056700000010063712540642614024766 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. import copy import json import mox from oslo.config import cfg from testtools.matchers import MatchesRegex from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.notification import stack as notification from heat.engine import parser from heat.engine.resources import instance from heat.engine.resources import loadbalancer as lb from heat.engine.resources import wait_condition as wc from heat.engine import stack_user from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils from heat.tests.v1_1 import fakes as fakes11 asg_tmpl_without_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create autoscaling group.", "Parameters" : {}, "Resources" : { "WebServerGroup" : { "Type" : "AWS::AutoScaling::AutoScalingGroup", "Properties" : { "AvailabilityZones" : ["nova"], "LaunchConfigurationName" : { "Ref" : "LaunchConfig" }, "MinSize" : "10", "MaxSize" : "20", "LoadBalancerNames" : [ { "Ref" : "ElasticLoadBalancer" } ] } }, "ElasticLoadBalancer" : { "Type" : "AWS::ElasticLoadBalancing::LoadBalancer", "Properties" : { "AvailabilityZones" : ["nova"], "Listeners" : [ { "LoadBalancerPort" : "80", "InstancePort" : "80", "Protocol" : "HTTP" }] } }, "LaunchConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "F20-x86_64-cfntools", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' asg_tmpl_with_bad_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create autoscaling group.", "Parameters" : {}, "Resources" : { "WebServerGroup" : { "UpdatePolicy": { "foo": { } }, "Type" : "AWS::AutoScaling::AutoScalingGroup", "Properties" : { "AvailabilityZones" : ["nova"], "LaunchConfigurationName" : { "Ref" : "LaunchConfig" }, "MinSize" : "10", "MaxSize" : "20" } }, "LaunchConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "F20-x86_64-cfntools", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' asg_tmpl_with_default_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create autoscaling group.", "Parameters" : {}, "Resources" : { "WebServerGroup" : { "UpdatePolicy" : { "AutoScalingRollingUpdate" : { } }, "Type" : "AWS::AutoScaling::AutoScalingGroup", "Properties" : { "AvailabilityZones" : ["nova"], "LaunchConfigurationName" : { "Ref" : "LaunchConfig" }, "MinSize" : "10", "MaxSize" : "20", "LoadBalancerNames" : [ { "Ref" : "ElasticLoadBalancer" } ] } }, "ElasticLoadBalancer" : { "Type" : "AWS::ElasticLoadBalancing::LoadBalancer", "Properties" : { "AvailabilityZones" : ["nova"], "Listeners" : [ { "LoadBalancerPort" : "80", "InstancePort" : "80", "Protocol" : "HTTP" }] } }, "LaunchConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "F20-x86_64-cfntools", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' asg_tmpl_with_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create autoscaling group.", "Parameters" : {}, "Resources" : { "WebServerGroup" : { "UpdatePolicy" : { "AutoScalingRollingUpdate" : { "MinInstancesInService" : "1", "MaxBatchSize" : "2", "PauseTime" : "PT1S" } }, "Type" : "AWS::AutoScaling::AutoScalingGroup", "Properties" : { "AvailabilityZones" : ["nova"], "LaunchConfigurationName" : { "Ref" : "LaunchConfig" }, "MinSize" : "10", "MaxSize" : "20", "LoadBalancerNames" : [ { "Ref" : "ElasticLoadBalancer" } ] } }, "ElasticLoadBalancer" : { "Type" : "AWS::ElasticLoadBalancing::LoadBalancer", "Properties" : { "AvailabilityZones" : ["nova"], "Listeners" : [ { "LoadBalancerPort" : "80", "InstancePort" : "80", "Protocol" : "HTTP" }] } }, "LaunchConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "F20-x86_64-cfntools", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' class AutoScalingGroupTest(HeatTestCase): def setUp(self): super(AutoScalingGroupTest, self).setUp() self.fc = fakes11.FakeClient() self.fkc = fakes.FakeKeystoneClient(username='test_stack.CfnLBUser') cfg.CONF.set_default('heat_waitcondition_server_url', 'http://127.0.0.1:8000/v1/waitcondition') utils.setup_dummy_db() def _stub_validate(self): self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate().MultipleTimes() def _stub_lb_create(self): self.m.StubOutWithMock(stack_user.StackUser, 'keystone') stack_user.StackUser.keystone().MultipleTimes().AndReturn(self.fkc) self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status') wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) def _stub_lb_reload(self, num=1, setup=True): if setup: self.m.StubOutWithMock(lb.LoadBalancer, 'handle_update') for i in range(num): lb.LoadBalancer.handle_update( mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(None) def _stub_grp_create(self, capacity=0, setup_lb=True): """ Expect creation of instances to capacity. By default, expect creation of load balancer unless specified. """ self._stub_validate() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') self.m.StubOutWithMock(notification, 'send') notification.send(mox.IgnoreArg()).MultipleTimes().AndReturn(None) cookie = object() clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) # for load balancer setup if setup_lb: self._stub_lb_create() self._stub_lb_reload() instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(True) # for each instance in group for i in range(capacity): instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(True) def _stub_grp_replace(self, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=0): """ Expect replacement of the capacity by batch size """ # for load balancer setup self._stub_lb_reload(num_reloads_expected_on_updt) self.m.StubOutWithMock(notification, 'send') notification.send(mox.IgnoreArg()).MultipleTimes().AndReturn(None) # for instances in the group self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') self.m.StubOutWithMock(instance.Instance, 'destroy') if num_reloads_expected_on_updt > 1: clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) cookie = object() for i in range(num_creates_expected_on_updt): instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(True) for i in range(num_deletes_expected_on_updt): instance.Instance.destroy().AndReturn(None) def _stub_grp_update(self, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=0): """ Expect update of the instances """ self.m.StubOutWithMock(instance.Instance, 'nova') instance.Instance.nova().MultipleTimes().AndReturn(self.fc) def activate_status(server): server.status = 'VERIFY_RESIZE' return_server = self.fc.servers.list()[1] return_server.id = 1234 return_server.get = activate_status.__get__(return_server) self.m.StubOutWithMock(self.fc.servers, 'get') self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') self.fc.servers.get(mox.IgnoreArg()).\ MultipleTimes().AndReturn(return_server) self.fc.client.post_servers_1234_action( body={'resize': {'flavorRef': 3}}).\ MultipleTimes().AndReturn((202, None)) self.fc.client.post_servers_1234_action( body={'confirmResize': None}).\ MultipleTimes().AndReturn((202, None)) self._stub_grp_replace(num_creates_expected_on_updt, num_deletes_expected_on_updt, num_reloads_expected_on_updt) def get_launch_conf_name(self, stack, ig_name): return stack[ig_name].properties['LaunchConfigurationName'] def test_parse_without_update_policy(self): tmpl = template_format.parse(asg_tmpl_without_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() grp = stack['WebServerGroup'] self.assertFalse(grp.update_policy['AutoScalingRollingUpdate']) def test_parse_with_update_policy(self): tmpl = template_format.parse(asg_tmpl_with_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() tmpl_grp = tmpl['Resources']['WebServerGroup'] tmpl_policy = tmpl_grp['UpdatePolicy']['AutoScalingRollingUpdate'] tmpl_batch_sz = int(tmpl_policy['MaxBatchSize']) grp = stack['WebServerGroup'] self.assertTrue(grp.update_policy) self.assertEqual(1, len(grp.update_policy)) self.assertIn('AutoScalingRollingUpdate', grp.update_policy) policy = grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(policy and len(policy) > 0) self.assertEqual(1, int(policy['MinInstancesInService'])) self.assertEqual(tmpl_batch_sz, int(policy['MaxBatchSize'])) self.assertEqual('PT1S', policy['PauseTime']) def test_parse_with_default_update_policy(self): tmpl = template_format.parse(asg_tmpl_with_default_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() grp = stack['WebServerGroup'] self.assertTrue(grp.update_policy) self.assertEqual(1, len(grp.update_policy)) self.assertIn('AutoScalingRollingUpdate', grp.update_policy) policy = grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(policy and len(policy) > 0) self.assertEqual(0, int(policy['MinInstancesInService'])) self.assertEqual(1, int(policy['MaxBatchSize'])) self.assertEqual('PT0S', policy['PauseTime']) def test_parse_with_bad_update_policy(self): tmpl = template_format.parse(asg_tmpl_with_bad_updt_policy) stack = utils.parse_stack(tmpl) self.assertRaises(exception.StackValidationFailed, stack.validate) def test_parse_with_bad_pausetime_in_update_policy(self): tmpl = template_format.parse(asg_tmpl_with_default_updt_policy) group = tmpl['Resources']['WebServerGroup'] policy = group['UpdatePolicy']['AutoScalingRollingUpdate'] policy['PauseTime'] = 'P1YT1H' stack = utils.parse_stack(tmpl) self.assertRaises(exception.StackValidationFailed, stack.validate) def validate_update_policy_diff(self, current, updated): # load current stack current_tmpl = template_format.parse(current) current_stack = utils.parse_stack(current_tmpl) # get the json snippet for the current InstanceGroup resource current_grp = current_stack['WebServerGroup'] current_snippets = dict((n, r.parsed_template()) for n, r in current_stack.items()) current_grp_json = current_snippets[current_grp.name] # load the updated stack updated_tmpl = template_format.parse(updated) updated_stack = utils.parse_stack(updated_tmpl) # get the updated json snippet for the InstanceGroup resource in the # context of the current stack updated_grp = updated_stack['WebServerGroup'] updated_grp_json = current_stack.resolve_runtime_data(updated_grp.t) # identify the template difference tmpl_diff = updated_grp.update_template_diff( updated_grp_json, current_grp_json) updated_policy = (updated_grp.t['UpdatePolicy'] if 'UpdatePolicy' in updated_grp.t else None) expected = {u'UpdatePolicy': updated_policy} self.assertEqual(expected, tmpl_diff) def test_update_policy_added(self): self.validate_update_policy_diff(asg_tmpl_without_updt_policy, asg_tmpl_with_updt_policy) def test_update_policy_updated(self): updt_template = json.loads(asg_tmpl_with_updt_policy) grp = updt_template['Resources']['WebServerGroup'] policy = grp['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '2' policy['MaxBatchSize'] = '4' policy['PauseTime'] = 'PT1M30S' self.validate_update_policy_diff(asg_tmpl_with_updt_policy, json.dumps(updt_template)) def test_update_policy_removed(self): self.validate_update_policy_diff(asg_tmpl_with_updt_policy, asg_tmpl_without_updt_policy) def update_autoscaling_group(self, init_template, updt_template, num_updates_expected_on_updt, num_creates_expected_on_updt, num_deletes_expected_on_updt, num_reloads_expected_on_updt, update_replace): # setup stack from the initial template tmpl = template_format.parse(init_template) stack = utils.parse_stack(tmpl) stack.validate() # test stack create size = int(stack['WebServerGroup'].properties['MinSize']) self._stub_grp_create(size) self.m.ReplayAll() stack.create() self.m.VerifyAll() self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['WebServerGroup'] self.assertTrue('AutoScalingRollingUpdate' in current_grp.update_policy) current_policy = current_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(current_policy) self.assertTrue(len(current_policy) > 0) init_updt_policy = tmpl['Resources']['WebServerGroup']['UpdatePolicy'] init_roll_updt = init_updt_policy['AutoScalingRollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['LaunchConfig'] conf_name_pattern = '%s-LaunchConfig-[a-zA-Z0-9]+$' % stack.name self.assertThat(conf.FnGetRefId(), MatchesRegex(conf_name_pattern)) # get launch conf name here to compare result after update conf_name = self.get_launch_conf_name(stack, 'WebServerGroup') # test the number of instances created nested = stack['WebServerGroup'].nested() self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() # saves info from initial list of instances for comparison later init_instances = current_grp.get_instances() init_names = current_grp.get_instance_names() init_images = [(i.name, i.t['Properties']['ImageId']) for i in init_instances] init_flavors = [(i.name, i.t['Properties']['InstanceType']) for i in init_instances] # test stack update updated_tmpl = template_format.parse(updt_template) updated_stack = utils.parse_stack(updated_tmpl) new_grp_tmpl = updated_tmpl['Resources']['WebServerGroup'] new_updt_pol = new_grp_tmpl['UpdatePolicy']['AutoScalingRollingUpdate'] new_batch_sz = int(new_updt_pol['MaxBatchSize']) self.assertNotEqual(new_batch_sz, init_batch_sz) self._stub_validate() if update_replace: self._stub_grp_replace(size, size, num_reloads_expected_on_updt) else: self._stub_grp_update(num_creates_expected_on_updt, num_deletes_expected_on_updt, num_reloads_expected_on_updt) self.stub_wallclock() self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that the update policy is updated updated_grp = stack['WebServerGroup'] updt_instances = updated_grp.get_instances() self.assertTrue('AutoScalingRollingUpdate' in updated_grp.update_policy) updated_policy = updated_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) self.assertEqual(new_batch_sz, int(updated_policy['MaxBatchSize'])) # test that the launch configuration is replaced updated_conf_name = self.get_launch_conf_name(stack, 'WebServerGroup') self.assertNotEqual(conf_name, updated_conf_name) # test that the group size are the same updt_instances = updated_grp.get_instances() updt_names = updated_grp.get_instance_names() self.assertEqual(len(init_names), len(updt_names)) # test that appropriate number of instance names are the same matched_names = set(updt_names) & set(init_names) self.assertEqual(num_updates_expected_on_updt, len(matched_names)) # test that the appropriate number of new instances are created self.assertEqual(num_creates_expected_on_updt, len(set(updt_names) - set(init_names))) # test that the appropriate number of instances are deleted self.assertEqual(num_deletes_expected_on_updt, len(set(init_names) - set(updt_names))) # test that the older instances are the ones being deleted if num_deletes_expected_on_updt > 0: deletes_expected = init_names[:num_deletes_expected_on_updt] self.assertNotIn(deletes_expected, updt_names) # test if instances are updated if update_replace: # test that the image id is changed for all instances updt_images = [(i.name, i.t['Properties']['ImageId']) for i in updt_instances] self.assertEqual(0, len(set(updt_images) & set(init_images))) else: # test that instance type is changed for all instances updt_flavors = [(i.name, i.t['Properties']['InstanceType']) for i in updt_instances] self.assertEqual(0, len(set(updt_flavors) & set(init_flavors))) def test_autoscaling_group_update_replace(self): """ Test simple update replace with no conflict in batch size and minimum instances in service. """ updt_template = json.loads(asg_tmpl_with_updt_policy) grp = updt_template['Resources']['WebServerGroup'] policy = grp['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '1' policy['MaxBatchSize'] = '3' config = updt_template['Resources']['LaunchConfig'] config['Properties']['ImageId'] = 'F17-x86_64-cfntools' self.update_autoscaling_group(asg_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=10, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=9, update_replace=True) def test_autoscaling_group_update_replace_with_adjusted_capacity(self): """ Test update replace with capacity adjustment due to conflict in batch size and minimum instances in service. """ updt_template = json.loads(asg_tmpl_with_updt_policy) grp = updt_template['Resources']['WebServerGroup'] policy = grp['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '8' policy['MaxBatchSize'] = '4' config = updt_template['Resources']['LaunchConfig'] config['Properties']['ImageId'] = 'F17-x86_64-cfntools' self.update_autoscaling_group(asg_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=8, num_creates_expected_on_updt=2, num_deletes_expected_on_updt=2, num_reloads_expected_on_updt=7, update_replace=True) def test_autoscaling_group_update_replace_huge_batch_size(self): """ Test update replace with a huge batch size. """ updt_template = json.loads(asg_tmpl_with_updt_policy) group = updt_template['Resources']['WebServerGroup'] policy = group['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '0' policy['MaxBatchSize'] = '20' config = updt_template['Resources']['LaunchConfig'] config['Properties']['ImageId'] = 'F17-x86_64-cfntools' self.update_autoscaling_group(asg_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=10, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=3, update_replace=True) def test_autoscaling_group_update_replace_huge_min_in_service(self): """ Test update replace with a huge number of minimum instances in service. """ updt_template = json.loads(asg_tmpl_with_updt_policy) group = updt_template['Resources']['WebServerGroup'] policy = group['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '20' policy['MaxBatchSize'] = '1' policy['PauseTime'] = 'PT0S' config = updt_template['Resources']['LaunchConfig'] config['Properties']['ImageId'] = 'F17-x86_64-cfntools' self.update_autoscaling_group(asg_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=9, num_creates_expected_on_updt=1, num_deletes_expected_on_updt=1, num_reloads_expected_on_updt=12, update_replace=True) def test_autoscaling_group_update_no_replace(self): """ Test simple update only and no replace (i.e. updated instance flavor in Launch Configuration) with no conflict in batch size and minimum instances in service. """ updt_template = json.loads(copy.deepcopy(asg_tmpl_with_updt_policy)) group = updt_template['Resources']['WebServerGroup'] policy = group['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '1' policy['MaxBatchSize'] = '3' policy['PauseTime'] = 'PT0S' config = updt_template['Resources']['LaunchConfig'] config['Properties']['InstanceType'] = 'm1.large' self.update_autoscaling_group(asg_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=10, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=6, update_replace=False) def test_instance_group_update_no_replace_with_adjusted_capacity(self): """ Test update only and no replace (i.e. updated instance flavor in Launch Configuration) with capacity adjustment due to conflict in batch size and minimum instances in service. """ updt_template = json.loads(copy.deepcopy(asg_tmpl_with_updt_policy)) group = updt_template['Resources']['WebServerGroup'] policy = group['UpdatePolicy']['AutoScalingRollingUpdate'] policy['MinInstancesInService'] = '8' policy['MaxBatchSize'] = '4' policy['PauseTime'] = 'PT0S' config = updt_template['Resources']['LaunchConfig'] config['Properties']['InstanceType'] = 'm1.large' self.update_autoscaling_group(asg_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=8, num_creates_expected_on_updt=2, num_deletes_expected_on_updt=2, num_reloads_expected_on_updt=5, update_replace=False) def test_autoscaling_group_update_policy_removed(self): # setup stack from the initial template tmpl = template_format.parse(asg_tmpl_with_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() # test stack create size = int(stack['WebServerGroup'].properties['MinSize']) self._stub_grp_create(size) self.m.ReplayAll() stack.create() self.m.VerifyAll() self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['WebServerGroup'] self.assertIn('AutoScalingRollingUpdate', current_grp.update_policy) current_policy = current_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(current_policy) self.assertTrue(len(current_policy) > 0) init_updt_policy = tmpl['Resources']['WebServerGroup']['UpdatePolicy'] init_roll_updt = init_updt_policy['AutoScalingRollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['LaunchConfig'] conf_name_pattern = '%s-LaunchConfig-[a-zA-Z0-9]+$' % stack.name self.assertThat(conf.FnGetRefId(), MatchesRegex(conf_name_pattern)) # test the number of instances created nested = stack['WebServerGroup'].nested() self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() # test stack update updated_tmpl = template_format.parse(asg_tmpl_without_updt_policy) updated_stack = utils.parse_stack(updated_tmpl) self._stub_grp_replace(num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=1) self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that update policy is removed updated_grp = stack['WebServerGroup'] self.assertFalse(updated_grp.update_policy['AutoScalingRollingUpdate']) def test_autoscaling_group_update_policy_check_timeout(self): # setup stack from the initial template tmpl = template_format.parse(asg_tmpl_with_updt_policy) stack = utils.parse_stack(tmpl) # test stack create size = int(stack['WebServerGroup'].properties['MinSize']) self._stub_grp_create(size) self.m.ReplayAll() stack.create() self.m.VerifyAll() self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['WebServerGroup'] self.assertIn('AutoScalingRollingUpdate', current_grp.update_policy) current_policy = current_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(current_policy) self.assertTrue(len(current_policy) > 0) init_updt_policy = tmpl['Resources']['WebServerGroup']['UpdatePolicy'] init_roll_updt = init_updt_policy['AutoScalingRollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test the number of instances created nested = stack['WebServerGroup'].nested() self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() # modify the pause time and test for error new_pause_time = 'PT30M' updt_template = json.loads(copy.deepcopy(asg_tmpl_with_updt_policy)) group = updt_template['Resources']['WebServerGroup'] policy = group['UpdatePolicy']['AutoScalingRollingUpdate'] policy['PauseTime'] = new_pause_time config = updt_template['Resources']['LaunchConfig'] config['Properties']['ImageId'] = 'F17-x86_64-cfntools' updated_tmpl = template_format.parse(json.dumps(updt_template)) updated_stack = utils.parse_stack(updated_tmpl) self._stub_grp_replace(num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, num_reloads_expected_on_updt=1) self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() self.assertEqual(('UPDATE', 'FAILED'), stack.state) # test that the update policy is updated updated_grp = stack['WebServerGroup'] self.assertIn('AutoScalingRollingUpdate', updated_grp.update_policy) updated_policy = updated_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) self.assertEqual(new_pause_time, updated_policy['PauseTime']) # test that error message match expected_error_message = ('The current UpdatePolicy will result ' 'in stack update timeout.') self.assertIn(expected_error_message, stack.status_reason) heat-2014.1.5/heat/tests/__init__.py0000664000567000056700000000137012540642614020226 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. # See http://code.google.com/p/python-nose/issues/detail?id=373 # The code below enables nosetests to work with i18n _() blocks import __builtin__ setattr(__builtin__, '_', lambda x: x) heat-2014.1.5/heat/tests/test_signal.py0000664000567000056700000003431112540642614021004 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. import datetime from keystoneclient import exceptions as kc_exceptions from oslo.config import cfg from heat.common import exception from heat.common import template_format from heat.db import api as db_api from heat.engine import clients from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.engine import stack_user from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import generic_resource from heat.tests import utils test_template_signal = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a test.", "Parameters" : {}, "Resources" : { "signal_handler" : {"Type" : "SignalResourceType"}, "resource_X" : {"Type" : "GenericResourceType"} } } ''' class SignalTest(HeatTestCase): def setUp(self): super(SignalTest, self).setUp() utils.setup_dummy_db() resource._register_class('SignalResourceType', generic_resource.SignalResource) resource._register_class('GenericResourceType', generic_resource.GenericResource) cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.stack_id = 'STACKABCD1234' self.fc = fakes.FakeKeystoneClient() def tearDown(self): super(SignalTest, self).tearDown() utils.reset_dummy_db() # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the stack is properly cleaned up def create_stack(self, stack_name='test_stack', stub=True): temp = template_format.parse(test_template_signal) template = parser.Template(temp) ctx = utils.dummy_context() ctx.tenant_id = 'test_tenant' stack = parser.Stack(ctx, stack_name, template, disable_rollback=True) # Stub out the stack ID so we have a known value with utils.UUIDStub(self.stack_id): stack.store() if stub: self.m.StubOutWithMock(stack_user.StackUser, 'keystone') stack_user.StackUser.keystone().MultipleTimes().AndReturn( self.fc) self.m.ReplayAll() return stack @utils.stack_delete_after def test_handle_create_fail_keypair_raise(self): self.stack = self.create_stack(stack_name='create_fail_keypair') self.m.StubOutWithMock(stack_user.StackUser, '_create_keypair') stack_user.StackUser._create_keypair().AndRaise(Exception('Failed')) self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.assertIn('Failed', rsrc.status_reason) self.assertEqual('1234', rs_data.get('user_id')) self.assertIsNone(rsrc.resource_id) self.m.VerifyAll() @utils.stack_delete_after def test_resource_data(self): self.stack = self.create_stack(stack_name='resource_data_test', stub=False) self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( fakes.FakeKeystoneClient( access='anaccesskey', secret='verysecret', credential_id='mycredential')) self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) # Ensure the resource data has been stored correctly rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual('mycredential', rs_data.get('credential_id')) self.assertEqual('anaccesskey', rs_data.get('access_key')) self.assertEqual('verysecret', rs_data.get('secret_key')) self.assertEqual('1234', rs_data.get('user_id')) self.assertEqual(rsrc.resource_id, rs_data.get('user_id')) self.assertEqual(4, len(rs_data.keys())) self.m.VerifyAll() @utils.stack_delete_after def test_get_user_id(self): self.stack = self.create_stack(stack_name='resource_data_test', stub=False) self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( fakes.FakeKeystoneClient( access='anaccesskey', secret='verysecret')) self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) # Ensure the resource data has been stored correctly rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual('1234', rs_data.get('user_id')) self.assertEqual('1234', rsrc.resource_id) self.assertEqual('1234', rsrc._get_user_id()) # Check user id can still be fetched from resource_id # if the resource data is not there. db_api.resource_data_delete(rsrc, 'user_id') self.assertRaises( exception.NotFound, db_api.resource_data_get, rsrc, 'user_id') self.assertEqual('1234', rsrc._get_user_id()) self.m.VerifyAll() @utils.stack_delete_after def test_FnGetAtt_Alarm_Url(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] created_time = datetime.datetime(2012, 11, 29, 13, 49, 37) rsrc.created_time = created_time self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) expected_url = "".join([ 'http://server.test:8000/v1/signal/', 'arn%3Aopenstack%3Aheat%3A%3Atest_tenant%3Astacks%2F', 'test_stack%2FSTACKABCD1234%2Fresources%2F', 'signal_handler?', 'Timestamp=2012-11-29T13%3A49%3A37Z&', 'SignatureMethod=HmacSHA256&', 'AWSAccessKeyId=4567&', 'SignatureVersion=2&', 'Signature=', 'VW4NyvRO4WhQdsQ4rxl5JMUr0AlefHN6OLsRz9oZyls%3D']) self.assertEqual(expected_url, rsrc.FnGetAtt('AlarmUrl')) self.m.VerifyAll() @utils.stack_delete_after def test_FnGetAtt_Alarm_Url_is_cached(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) first_url = rsrc.FnGetAtt('AlarmUrl') second_url = rsrc.FnGetAtt('AlarmUrl') self.assertEqual(first_url, second_url) self.m.VerifyAll() @utils.stack_delete_after def test_FnGetAtt_delete(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertIn('http://server.test:8000/v1/signal', rsrc.FnGetAtt('AlarmUrl')) scheduler.TaskRunner(rsrc.delete)() self.assertEqual('None', rsrc.FnGetAtt('AlarmUrl')) self.m.VerifyAll() @utils.stack_delete_after def test_delete_not_found(self): self.stack = self.create_stack(stack_name='test_delete_not_found', stub=False) class FakeKeystoneClientFail(fakes.FakeKeystoneClient): def delete_stack_user(self, name): raise kc_exceptions.NotFound() self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( FakeKeystoneClientFail()) self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_signal(self): test_d = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '123'} self.stack = self.create_stack() # to confirm we get a call to handle_signal self.m.StubOutWithMock(generic_resource.SignalResource, 'handle_signal') generic_resource.SignalResource.handle_signal(test_d).AndReturn(None) self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertTrue(rsrc.requires_deferred_auth) rsrc.signal(details=test_d) self.m.VerifyAll() @utils.stack_delete_after def test_signal_different_reason_types(self): self.stack = self.create_stack() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertTrue(rsrc.requires_deferred_auth) ceilo_details = {'current': 'foo', 'reason': 'apples', 'previous': 'SUCCESS'} ceilo_expected = 'alarm state changed from SUCCESS to foo (apples)' watch_details = {'state': 'go_for_it'} watch_expected = 'alarm state changed to go_for_it' str_details = 'a string details' str_expected = str_details none_details = None none_expected = 'No signal details provided' # signal from a successful deployment sds_details = {'deploy_stdout': 'foo', 'deploy_stderr': 'bar', 'deploy_status_code': 0} sds_expected = 'deployment succeeded' # signal from a failed deployment sdf_details = {'deploy_stdout': 'foo', 'deploy_stderr': 'bar', 'deploy_status_code': -1} sdf_expected = 'deployment failed (-1)' # to confirm we get a string reason self.m.StubOutWithMock(generic_resource.SignalResource, '_add_event') generic_resource.SignalResource._add_event( 'signal', 'COMPLETE', ceilo_expected).AndReturn(None) generic_resource.SignalResource._add_event( 'signal', 'COMPLETE', watch_expected).AndReturn(None) generic_resource.SignalResource._add_event( 'signal', 'COMPLETE', str_expected).AndReturn(None) generic_resource.SignalResource._add_event( 'signal', 'COMPLETE', none_expected).AndReturn(None) generic_resource.SignalResource._add_event( 'signal', 'COMPLETE', sds_expected).AndReturn(None) generic_resource.SignalResource._add_event( 'signal', 'COMPLETE', sdf_expected).AndReturn(None) self.m.ReplayAll() for test_d in (ceilo_details, watch_details, str_details, none_details, sds_details, sdf_details): rsrc.signal(details=test_d) self.m.VerifyAll() self.m.UnsetStubs() # Since we unset the stubs above we must re-stub keystone to keep the # test isolated from keystoneclient. The unset stubs is done so that we # do not have to mock out all of the deleting that the # stack_delete_after decorator will do during cleanup. self.m.StubOutWithMock(self.stack.clients, 'keystone') self.stack.clients.keystone().AndReturn(self.fc) self.m.ReplayAll() @utils.stack_delete_after def test_signal_wrong_resource(self): # assert that we get the correct exception when calling a # resource.signal() that does not have a handle_signal() self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['resource_X'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) err_metadata = {'Data': 'foo', 'Status': 'SUCCESS', 'UniqueId': '123'} self.assertRaises(exception.ResourceFailure, rsrc.signal, details=err_metadata) self.m.VerifyAll() @utils.stack_delete_after def test_signal_reception_wrong_state(self): # assert that we get the correct exception when calling a # resource.signal() that is in having a destructive action. self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) # manually override the action to DELETE rsrc.action = rsrc.DELETE err_metadata = {'Data': 'foo', 'Status': 'SUCCESS', 'UniqueId': '123'} self.assertRaises(exception.ResourceFailure, rsrc.signal, details=err_metadata) self.m.VerifyAll() @utils.stack_delete_after def test_signal_reception_failed_call(self): # assert that we get the correct exception from resource.signal() # when resource.handle_signal() raises an exception. self.stack = self.create_stack() test_d = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '123'} # to confirm we get a call to handle_signal self.m.StubOutWithMock(generic_resource.SignalResource, 'handle_signal') generic_resource.SignalResource.handle_signal(test_d).AndRaise( ValueError) self.m.ReplayAll() self.stack.create() rsrc = self.stack['signal_handler'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertRaises(exception.ResourceFailure, rsrc.signal, details=test_d) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_clients.py0000664000567000056700000000457012540642614021174 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. import mock from heat.engine import clients from heat.tests.common import HeatTestCase from heatclient import client as heatclient class ClientsTest(HeatTestCase): def test_clients_chosen_at_module_initilization(self): self.assertFalse(hasattr(clients.Clients, 'nova')) self.assertTrue(hasattr(clients.Clients('fakecontext'), 'nova')) def test_clients_get_heat_url(self): con = mock.Mock() con.tenant_id = "b363706f891f48019483f8bd6503c54b" obj = clients.Clients(con) obj._get_client_option = mock.Mock() obj._get_client_option.return_value = None self.assertIsNone(obj._get_heat_url()) heat_url = "http://0.0.0.0:8004/v1/%(tenant_id)s" obj._get_client_option.return_value = heat_url tenant_id = "b363706f891f48019483f8bd6503c54b" result = heat_url % {"tenant_id": tenant_id} self.assertEqual(result, obj._get_heat_url()) obj._get_client_option.return_value = result self.assertEqual(result, obj._get_heat_url()) @mock.patch.object(heatclient, 'Client') def test_clients_heat(self, mock_call): con = mock.Mock() con.auth_url = "http://auth.example.com:5000/v2.0" con.tenant_id = "b363706f891f48019483f8bd6503c54b" con.auth_token = "3bcc3d3a03f44e3d8377f9247b0ad155" obj = clients.Clients(con) obj._get_heat_url = mock.Mock(name="_get_heat_url") obj._get_heat_url.return_value = None obj.url_for = mock.Mock(name="url_for") obj.url_for.return_value = "url_from_keystone" obj.heat() self.assertEqual('url_from_keystone', mock_call.call_args[0][1]) obj._get_heat_url.return_value = "url_from_config" obj._heat = None obj.heat() self.assertEqual('url_from_config', mock_call.call_args[0][1]) heat-2014.1.5/heat/tests/common.py0000664000567000056700000000560512540642614017764 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. import logging import os import sys import time import fixtures import mox from oslo.config import cfg import testscenarios import testtools from heat.engine import environment from heat.engine import resources from heat.engine import scheduler from heat.openstack.common.fixture import mockpatch class HeatTestCase(testscenarios.WithScenarios, testtools.TestCase): TIME_STEP = 0.1 def setUp(self): super(HeatTestCase, self).setUp() self.m = mox.Mox() self.addCleanup(self.m.UnsetStubs) self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG)) scheduler.ENABLE_SLEEP = False self.useFixture(fixtures.MonkeyPatch( 'heat.common.exception._FATAL_EXCEPTION_FORMAT_ERRORS', True)) def enable_sleep(): scheduler.ENABLE_SLEEP = True self.addCleanup(enable_sleep) mod_dir = os.path.dirname(sys.modules[__name__].__file__) project_dir = os.path.abspath(os.path.join(mod_dir, '../../')) env_dir = os.path.join(project_dir, 'etc', 'heat', 'environment.d') cfg.CONF.set_default('environment_dir', env_dir) cfg.CONF.set_override('allowed_rpc_exception_modules', ['heat.common.exception', 'exceptions']) self.addCleanup(cfg.CONF.reset) tri = resources.global_env().get_resource_info( 'AWS::RDS::DBInstance', registry_type=environment.TemplateResourceInfo) if tri is not None: cur_path = tri.template_name templ_path = os.path.join(project_dir, 'etc', 'heat', 'templates') if templ_path not in cur_path: tri.template_name = cur_path.replace('/etc/heat/templates', templ_path) def stub_wallclock(self): """ Overrides scheduler wallclock to speed up tests expecting timeouts. """ self._wallclock = time.time() def fake_wallclock(): self._wallclock += self.TIME_STEP return self._wallclock self.m.StubOutWithMock(scheduler, 'wallclock') scheduler.wallclock = fake_wallclock def patchobject(self, obj, attr): mockfixture = self.useFixture(mockpatch.PatchObject(obj, attr)) return mockfixture.mock heat-2014.1.5/heat/tests/test_image.py0000664000567000056700000000276112540642614020615 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. import mock from heat.common import exception from heat.engine import clients from heat.engine.resources import image from heat.engine.resources import nova_utils from heat.tests.common import HeatTestCase class ImageConstraintTest(HeatTestCase): @mock.patch.object(nova_utils, 'get_image_id') def test_validation(self, mock_get_image): with mock.patch.object(clients, "OpenStackClients"): constraint = image.ImageConstraint() mock_get_image.return_value = "id1" self.assertTrue(constraint.validate("foo", None)) @mock.patch.object(nova_utils, 'get_image_id') def test_validation_error(self, mock_get_image): with mock.patch.object(clients, "OpenStackClients"): constraint = image.ImageConstraint() mock_get_image.side_effect = exception.ImageNotFound( image_name='bar') self.assertFalse(constraint.validate("bar", None)) heat-2014.1.5/heat/tests/test_dbinstance.py0000664000567000056700000001014212540642614021635 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. from heat.common import template_format from heat.engine import parser from heat.engine import resource from heat.tests.common import HeatTestCase from heat.tests import utils rds_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "RDS Test", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "DatabaseServer": { "Type": "AWS::RDS::DBInstance", "Properties": { "DBName" : "wordpress", "Engine" : "MySQL", "MasterUsername" : "admin", "DBInstanceClass" : "db.m1.small", "DBSecurityGroups" : [], "AllocatedStorage" : "5", "MasterUserPassword": "admin" } } } } ''' class DBInstance(resource.Resource): """This is copied from the old DBInstance to verify the schema of the new TemplateResource. """ properties_schema = { 'DBSnapshotIdentifier': {'Type': 'String', 'Implemented': False}, 'AllocatedStorage': {'Type': 'String', 'Required': True}, 'AvailabilityZone': {'Type': 'String', 'Implemented': False}, 'BackupRetentionPeriod': {'Type': 'String', 'Implemented': False}, 'DBInstanceClass': {'Type': 'String', 'Required': True}, 'DBName': {'Type': 'String', 'Required': False}, 'DBParameterGroupName': {'Type': 'String', 'Implemented': False}, 'DBSecurityGroups': {'Type': 'List', 'Required': False, 'Default': []}, 'DBSubnetGroupName': {'Type': 'String', 'Implemented': False}, 'Engine': {'Type': 'String', 'AllowedValues': ['MySQL'], 'Required': True}, 'EngineVersion': {'Type': 'String', 'Implemented': False}, 'LicenseModel': {'Type': 'String', 'Implemented': False}, 'MasterUsername': {'Type': 'String', 'Required': True}, 'MasterUserPassword': {'Type': 'String', 'Required': True}, 'Port': {'Type': 'String', 'Default': '3306', 'Required': False}, 'PreferredBackupWindow': {'Type': 'String', 'Implemented': False}, 'PreferredMaintenanceWindow': {'Type': 'String', 'Implemented': False}, 'MultiAZ': {'Type': 'Boolean', 'Implemented': False}, } # We only support a couple of the attributes right now attributes_schema = { "Endpoint.Address": "Connection endpoint for the database.", "Endpoint.Port": ("The port number on which the database accepts " "connections.") } class DBInstanceTest(HeatTestCase): def setUp(self): super(DBInstanceTest, self).setUp() utils.setup_dummy_db() def test_dbinstance(self): """test that the Template is parsable and publishes the correct properties. """ templ = parser.Template(template_format.parse(rds_template)) stack = parser.Stack(utils.dummy_context(), 'test_stack', templ) res = stack['DatabaseServer'] self.assertIsNone(res._validate_against_facade(DBInstance)) heat-2014.1.5/heat/tests/test_hot.py0000664000567000056700000014511012540642614020321 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. from heat.common import exception from heat.common import identifier from heat.common import template_format from heat.engine import constraints from heat.engine import environment from heat.engine import function from heat.engine.hot import parameters as hot_param from heat.engine.hot import template as hot_template from heat.engine import parameters from heat.engine import parser from heat.engine import resource from heat.engine import resources from heat.engine import template from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import test_parser from heat.tests import utils hot_tpl_empty = template_format.parse(''' heat_template_version: 2013-05-23 ''') hot_tpl_generic_resource = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: GenericResourceType ''') hot_tpl_complex_attrs = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: ResourceWithComplexAttributesType ''') hot_tpl_mapped_props = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: ResWithComplexPropsAndAttrsType resource2: type: ResWithComplexPropsAndAttrsType properties: a_list: { get_attr: [ resource1, list] } a_string: { get_attr: [ resource1, string ] } a_map: { get_attr: [ resource1, map] } ''') class HOTemplateTest(HeatTestCase): """Test processing of HOT templates.""" @staticmethod def resolve(snippet, template, stack=None): return function.resolve(template.parse(stack, snippet)) def test_defaults(self): """Test default content behavior of HOT template.""" tmpl = parser.Template(hot_tpl_empty) # check if we get the right class self.assertIsInstance(tmpl, hot_template.HOTemplate) # test getting an invalid section self.assertNotIn('foobar', tmpl) # test defaults for valid sections self.assertEqual('No description', tmpl[tmpl.DESCRIPTION]) self.assertEqual({}, tmpl[tmpl.RESOURCES]) self.assertEqual({}, tmpl[tmpl.OUTPUTS]) def test_translate_resources_good(self): """Test translation of resources into internal engine format.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') expected = {'resource1': {'Type': 'AWS::EC2::Instance', 'Properties': {'property1': 'value1'}, 'Metadata': {'foo': 'bar'}, 'DependsOn': 'dummy', 'DeletionPolicy': 'dummy', 'UpdatePolicy': {'foo': 'bar'}}} tmpl = parser.Template(hot_tpl) self.assertEqual(expected, tmpl[tmpl.RESOURCES]) def test_translate_resources_bad_type(self): """Test translation of resources including invalid keyword.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: Type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.RESOURCES) self.assertEqual('u\'"Type" is not a valid keyword ' 'inside a resource definition\'', str(err)) def test_translate_resources_bad_properties(self): """Test translation of resources including invalid keyword.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance Properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.RESOURCES) self.assertEqual('u\'"Properties" is not a valid keyword ' 'inside a resource definition\'', str(err)) def test_translate_resources_bad_metadata(self): """Test translation of resources including invalid keyword.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 Metadata: foo: bar depends_on: dummy deletion_policy: dummy update_policy: foo: bar ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.RESOURCES) self.assertEqual('u\'"Metadata" is not a valid keyword ' 'inside a resource definition\'', str(err)) def test_translate_resources_bad_depends_on(self): """Test translation of resources including invalid keyword.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar DependsOn: dummy deletion_policy: dummy update_policy: foo: bar ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.RESOURCES) self.assertEqual('u\'"DependsOn" is not a valid keyword ' 'inside a resource definition\'', str(err)) def test_translate_resources_bad_deletion_polciy(self): """Test translation of resources including invalid keyword.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy DeletionPolicy: dummy update_policy: foo: bar ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.RESOURCES) self.assertEqual('u\'"DeletionPolicy" is not a valid keyword ' 'inside a resource definition\'', str(err)) def test_translate_resources_bad_update_policy(self): """Test translation of resources including invalid keyword.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: resource1: type: AWS::EC2::Instance properties: property1: value1 metadata: foo: bar depends_on: dummy deletion_policy: dummy UpdatePolicy: foo: bar ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.RESOURCES) self.assertEqual('u\'"UpdatePolicy" is not a valid keyword ' 'inside a resource definition\'', str(err)) def test_translate_outputs_good(self): """Test translation of outputs into internal engine format.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 outputs: output1: description: output1 value: value1 ''') expected = {'output1': {'Description': 'output1', 'Value': 'value1'}} tmpl = parser.Template(hot_tpl) self.assertEqual(expected, tmpl[tmpl.OUTPUTS]) def test_translate_outputs_bad_description(self): """Test translation of outputs into internal engine format.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 outputs: output1: Description: output1 value: value1 ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.OUTPUTS) self.assertIn('Description', str(err)) def test_translate_outputs_bad_value(self): """Test translation of outputs into internal engine format.""" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 outputs: output1: description: output1 Value: value1 ''') tmpl = parser.Template(hot_tpl) err = self.assertRaises(KeyError, tmpl.__getitem__, tmpl.OUTPUTS) self.assertIn('Value', str(err)) def test_resource_group_list_join(self): """Test list_join on a ResourceGroup's inner attributes This should not fail during validation (i.e. before the ResourceGroup can return the list of the runtime values. """ hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 resources: rg: type: OS::Heat::ResourceGroup properties: count: 3 resource_def: type: OS::Nova::Server ''') tmpl = parser.Template(hot_tpl) stack = parser.Stack(utils.dummy_context(), 'test_stack', tmpl) snippet = {'Fn::Join': ["\n", {'get_attr': ['rg', 'name']}]} self.assertEqual(self.resolve(snippet, tmpl, stack), '') def test_str_replace(self): """Test str_replace function.""" snippet = {'str_replace': {'template': 'Template var1 string var2', 'params': {'var1': 'foo', 'var2': 'bar'}}} snippet_resolved = 'Template foo string bar' tmpl = parser.Template(hot_tpl_empty) self.assertEqual(snippet_resolved, self.resolve(snippet, tmpl)) def test_str_replace_number(self): """Test str_replace function with numbers.""" snippet = {'str_replace': {'template': 'Template number string bar', 'params': {'number': 1}}} snippet_resolved = 'Template 1 string bar' tmpl = parser.Template(hot_tpl_empty) self.assertEqual(snippet_resolved, self.resolve(snippet, tmpl)) def test_str_fn_replace(self): """Test Fn:Replace function.""" snippet = {'Fn::Replace': [{'$var1': 'foo', '$var2': 'bar'}, 'Template $var1 string $var2']} snippet_resolved = 'Template foo string bar' tmpl = parser.Template(hot_tpl_empty) self.assertEqual(snippet_resolved, self.resolve(snippet, tmpl)) def test_str_replace_syntax(self): """ Test str_replace function syntax. Pass wrong syntax (array instead of dictionary) to function and validate that we get a TypeError. """ snippet = {'str_replace': [{'template': 'Template var1 string var2'}, {'params': {'var1': 'foo', 'var2': 'bar'}}]} tmpl = parser.Template(hot_tpl_empty) self.assertRaises(TypeError, self.resolve, snippet, tmpl) def test_str_replace_invalid_param_keys(self): """ Test str_replace function parameter keys. Pass wrong parameters to function and verify that we get a KeyError. """ snippet = {'str_replace': {'tmpl': 'Template var1 string var2', 'params': {'var1': 'foo', 'var2': 'bar'}}} tmpl = parser.Template(hot_tpl_empty) self.assertRaises(KeyError, self.resolve, snippet, tmpl) snippet = {'str_replace': {'tmpl': 'Template var1 string var2', 'parms': {'var1': 'foo', 'var2': 'bar'}}} self.assertRaises(KeyError, self.resolve, snippet, tmpl) def test_str_replace_invalid_param_types(self): """ Test str_replace function parameter values. Pass parameter values of wrong type to function and verify that we get a TypeError. """ snippet = {'str_replace': {'template': 12345, 'params': {'var1': 'foo', 'var2': 'bar'}}} tmpl = parser.Template(hot_tpl_empty) self.assertRaises(TypeError, self.resolve, snippet, tmpl) snippet = {'str_replace': {'template': 'Template var1 string var2', 'params': ['var1', 'foo', 'var2', 'bar']}} self.assertRaises(TypeError, self.resolve, snippet, tmpl) def test_get_file(self): """Test get_file function.""" snippet = {'get_file': 'file:///tmp/foo.yaml'} snippet_resolved = 'foo contents' tmpl = parser.Template(hot_tpl_empty, files={ 'file:///tmp/foo.yaml': 'foo contents' }) stack = parser.Stack(utils.dummy_context(), 'param_id_test', tmpl) self.assertEqual(snippet_resolved, self.resolve(snippet, tmpl, stack)) def test_get_file_not_string(self): """Test get_file function with non-string argument.""" snippet = {'get_file': ['file:///tmp/foo.yaml']} tmpl = parser.Template(hot_tpl_empty) stack = parser.Stack(utils.dummy_context(), 'param_id_test', tmpl) notStrErr = self.assertRaises(TypeError, self.resolve, snippet, tmpl, stack) self.assertEqual( 'Argument to "get_file" must be a string', str(notStrErr)) def test_get_file_missing_files(self): """Test get_file function with no matching key in files section.""" snippet = {'get_file': 'file:///tmp/foo.yaml'} tmpl = parser.Template(hot_tpl_empty, files={ 'file:///tmp/bar.yaml': 'bar contents' }) stack = parser.Stack(utils.dummy_context(), 'param_id_test', tmpl) missingErr = self.assertRaises(ValueError, self.resolve, snippet, tmpl, stack) self.assertEqual( ('No content found in the "files" section for ' 'get_file path: file:///tmp/foo.yaml'), str(missingErr)) def test_get_file_nested_does_not_resolve(self): """Test get_file function does not resolve nested calls.""" snippet = {'get_file': 'file:///tmp/foo.yaml'} snippet_resolved = '{get_file: file:///tmp/bar.yaml}' tmpl = parser.Template(hot_tpl_empty, files={ 'file:///tmp/foo.yaml': snippet_resolved, 'file:///tmp/bar.yaml': 'bar content', }) stack = parser.Stack(utils.dummy_context(), 'param_id_test', tmpl) self.assertEqual(snippet_resolved, self.resolve(snippet, tmpl, stack)) def test_prevent_parameters_access(self): """ Test that the parameters section can't be accesed using the template as a dictionary. """ expected_description = "This can be accessed" hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 description: {0} parameters: foo: type: string '''.format(expected_description)) tmpl = parser.Template(hot_tpl) self.assertEqual(expected_description, tmpl['description']) err_str = "can not be accessed directly" #Hot template test keyError = self.assertRaises(KeyError, tmpl.__getitem__, 'parameters') self.assertIn(err_str, str(keyError)) #CFN template test keyError = self.assertRaises(KeyError, tmpl.__getitem__, 'Parameters') self.assertIn(err_str, str(keyError)) def test_parameters_section_not_iterable(self): """ Test that the parameters section is not returned when the template is used as an iterable. """ expected_description = "This can be accessed" tmpl = parser.Template({'heat_template_version': '2013-05-23', 'description': expected_description, 'parameters': {'foo': {'Type': 'String', 'Required': True}}}) self.assertEqual(expected_description, tmpl['description']) self.assertNotIn('parameters', tmpl.keys()) def test_invalid_hot_version(self): """ Test HOT version check. Pass an invalid HOT version to template.Template.__new__() and validate that we get a ValueError. """ tmpl_str = "heat_template_version: this-ain't-valid" hot_tmpl = template_format.parse(tmpl_str) self.assertRaises(exception.InvalidTemplateVersion, template.Template, hot_tmpl) def test_valid_hot_version(self): """ Test HOT version check. Pass a valid HOT version to template.Template.__new__() and validate that we get back a parsed template. """ tmpl_str = "heat_template_version: 2013-05-23" hot_tmpl = template_format.parse(tmpl_str) parsed_tmpl = template.Template(hot_tmpl) expected = ('heat_template_version', '2013-05-23') observed = parsed_tmpl.version self.assertEqual(expected, observed) def test_resource_facade(self): metadata_snippet = {'resource_facade': 'metadata'} deletion_policy_snippet = {'resource_facade': 'deletion_policy'} update_policy_snippet = {'resource_facade': 'update_policy'} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.t = {'DeletionPolicy': 'Retain', 'UpdatePolicy': {"blarg": "wibble"}} parent_resource.stack = parser.Stack(utils.dummy_context(), 'toplevel_stack', parser.Template({})) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(hot_tpl_empty), parent_resource=parent_resource) self.assertEqual({"foo": "bar"}, self.resolve(metadata_snippet, stack.t, stack)) self.assertEqual('Retain', self.resolve(deletion_policy_snippet, stack.t, stack)) self.assertEqual({"blarg": "wibble"}, self.resolve(update_policy_snippet, stack.t, stack)) def test_resource_facade_function(self): deletion_policy_snippet = {'resource_facade': 'deletion_policy'} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.stack = parser.Stack(utils.dummy_context(), 'toplevel_stack', parser.Template({})) parent_snippet = {'DeletionPolicy': {'Fn::Join': ['eta', ['R', 'in']]}} parent_tmpl = parent_resource.stack.t.parse(parent_resource.stack, parent_snippet) parent_resource.t = parent_tmpl stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(hot_tpl_empty), parent_resource=parent_resource) self.assertEqual('Retain', self.resolve(deletion_policy_snippet, stack.t, stack)) def test_resource_facade_invalid_arg(self): snippet = {'resource_facade': 'wibble'} stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(hot_tpl_empty)) error = self.assertRaises(ValueError, self.resolve, snippet, stack.t, stack) self.assertIn(snippet.keys()[0], str(error)) def test_resource_facade_missing_deletion_policy(self): snippet = {'resource_facade': 'deletion_policy'} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.t = {} parent_resource.stack = parser.Stack(utils.dummy_context(), 'toplevel_stack', parser.Template({})) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(hot_tpl_empty), parent_resource=parent_resource) self.assertEqual('Delete', self.resolve(snippet, stack.t, stack)) class StackTest(test_parser.StackTest): """Test stack function when stack was created from HOT template.""" def resolve(self, snippet): return function.resolve(self.stack.t.parse(self.stack, snippet)) @utils.stack_delete_after def test_get_attr_multiple_rsrc_status(self): """Test resolution of get_attr occurrences in HOT template.""" hot_tpl = hot_tpl_generic_resource self.stack = parser.Stack(self.ctx, 'test_get_attr', template.Template(hot_tpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) snippet = {'Value': {'get_attr': ['resource1', 'foo']}} rsrc = self.stack['resource1'] for action, status in ( (rsrc.CREATE, rsrc.IN_PROGRESS), (rsrc.CREATE, rsrc.COMPLETE), (rsrc.RESUME, rsrc.IN_PROGRESS), (rsrc.RESUME, rsrc.COMPLETE), (rsrc.UPDATE, rsrc.IN_PROGRESS), (rsrc.UPDATE, rsrc.COMPLETE)): rsrc.state_set(action, status) # GenericResourceType has an attribute 'foo' which yields the # resource name. self.assertEqual({'Value': 'resource1'}, self.resolve(snippet)) @utils.stack_delete_after def test_get_attr_invalid(self): """Test resolution of get_attr occurrences in HOT template.""" hot_tpl = hot_tpl_generic_resource self.stack = parser.Stack(self.ctx, 'test_get_attr', template.Template(hot_tpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertRaises(exception.InvalidTemplateAttribute, self.resolve, {'Value': {'get_attr': ['resource1', 'NotThere']}}) @utils.stack_delete_after def test_get_attr_invalid_resource(self): """Test resolution of get_attr occurrences in HOT template.""" hot_tpl = hot_tpl_complex_attrs self.stack = parser.Stack(self.ctx, 'test_get_attr_invalid_none', template.Template(hot_tpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) snippet = {'Value': {'get_attr': ['resource2', 'who_cares']}} self.assertRaises(exception.InvalidTemplateAttribute, self.resolve, snippet) @utils.stack_delete_after def test_get_resource(self): """Test resolution of get_resource occurrences in HOT template.""" hot_tpl = hot_tpl_generic_resource self.stack = parser.Stack(self.ctx, 'test_get_resource', template.Template(hot_tpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) snippet = {'value': {'get_resource': 'resource1'}} self.assertEqual({'value': 'resource1'}, self.resolve(snippet)) @utils.stack_delete_after def test_set_param_id(self): tmpl = parser.Template(hot_tpl_empty) self.stack = parser.Stack(self.ctx, 'param_id_test', tmpl) self.assertEqual(self.stack.parameters['OS::stack_id'], 'None') self.stack.store() stack_identifier = self.stack.identifier() self.assertEqual(self.stack.parameters['OS::stack_id'], self.stack.id) self.assertEqual(self.stack.parameters['OS::stack_id'], stack_identifier.stack_id) self.m.VerifyAll() def test_set_wrong_param(self): tmpl = parser.Template(hot_tpl_empty) stack_id = identifier.HeatIdentifier('', "stack_testit", None) params = tmpl.parameters(None, {}) self.assertFalse(params.set_stack_id(None)) self.assertTrue(params.set_stack_id(stack_id)) @utils.stack_delete_after def test_set_param_id_update(self): tmpl = template.Template( {'heat_template_version': '2013-05-23', 'resources': {'AResource': {'type': 'ResourceWithPropsType', 'metadata': {'Bar': {'get_param': 'OS::stack_id'}}, 'properties': {'Foo': 'abc'}}}}) self.stack = parser.Stack(self.ctx, 'update_stack_id_test', tmpl) self.stack.store() self.stack.create() self.assertEqual(self.stack.state, (parser.Stack.CREATE, parser.Stack.COMPLETE)) stack_id = self.stack.parameters['OS::stack_id'] tmpl2 = template.Template( {'heat_template_version': '2013-05-23', 'resources': {'AResource': {'type': 'ResourceWithPropsType', 'metadata': {'Bar': {'get_param': 'OS::stack_id'}}, 'properties': {'Foo': 'xyz'}}}}) updated_stack = parser.Stack(self.ctx, 'updated_stack', tmpl2) self.stack.update(updated_stack) self.assertEqual(self.stack.state, (parser.Stack.UPDATE, parser.Stack.COMPLETE)) self.assertEqual(self.stack['AResource'].properties['Foo'], 'xyz') self.assertEqual(self.stack['AResource'].metadata['Bar'], stack_id) @utils.stack_delete_after def test_load_param_id(self): tmpl = parser.Template(hot_tpl_empty) self.stack = parser.Stack(self.ctx, 'param_load_id_test', tmpl) self.stack.store() stack_identifier = self.stack.identifier() self.assertEqual(self.stack.parameters['OS::stack_id'], stack_identifier.stack_id) newstack = parser.Stack.load(self.ctx, stack_id=self.stack.id) self.assertEqual(newstack.parameters['OS::stack_id'], stack_identifier.stack_id) @utils.stack_delete_after def test_update_modify_param_ok_replace(self): tmpl = { 'heat_template_version': '2013-05-23', 'parameters': { 'foo': {'type': 'string'} }, 'resources': { 'AResource': { 'type': 'ResourceWithPropsType', 'properties': {'Foo': {'get_param': 'foo'}} } } } self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'update_template_diff') self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), environment.Environment({'foo': 'abc'})) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl), environment.Environment({'foo': 'xyz'})) def check_props(*args): self.assertEqual('abc', self.stack['AResource'].properties['Foo']) generic_rsrc.ResourceWithProps.update_template_diff( {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}, {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}).WithSideEffects(check_props) \ .AndRaise(resource.UpdateReplace) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('xyz', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() class StackAttributesTest(HeatTestCase): """ Test stack get_attr function when stack was created from HOT template. """ def setUp(self): super(StackAttributesTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) resource._register_class('ResourceWithComplexAttributesType', generic_rsrc.ResourceWithComplexAttributes) resource._register_class('ResWithComplexPropsAndAttrsType', generic_rsrc.ResWithComplexPropsAndAttrs) self.m.ReplayAll() scenarios = [ ('get_flat_attr', dict(hot_tpl=hot_tpl_generic_resource, snippet={'Value': {'get_attr': ['resource1', 'foo']}}, resource_name='resource1', expected={'Value': 'resource1'})), ('get_list_attr', dict(hot_tpl=hot_tpl_complex_attrs, snippet={'Value': {'get_attr': ['resource1', 'list', 0]}}, resource_name='resource1', expected={ 'Value': generic_rsrc.ResourceWithComplexAttributes.list[0]})), ('get_flat_dict_attr', dict(hot_tpl=hot_tpl_complex_attrs, snippet={'Value': {'get_attr': ['resource1', 'flat_dict', 'key2']}}, resource_name='resource1', expected={ 'Value': generic_rsrc.ResourceWithComplexAttributes. flat_dict['key2']})), ('get_nested_attr_list', dict(hot_tpl=hot_tpl_complex_attrs, snippet={'Value': {'get_attr': ['resource1', 'nested_dict', 'list', 0]}}, resource_name='resource1', expected={ 'Value': generic_rsrc.ResourceWithComplexAttributes. nested_dict['list'][0]})), ('get_nested_attr_dict', dict(hot_tpl=hot_tpl_complex_attrs, snippet={'Value': {'get_attr': ['resource1', 'nested_dict', 'dict', 'a']}}, resource_name='resource1', expected={ 'Value': generic_rsrc.ResourceWithComplexAttributes. nested_dict['dict']['a']})), ('get_attr_none', dict(hot_tpl=hot_tpl_complex_attrs, snippet={'Value': {'get_attr': ['resource1', 'none', 'who_cares']}}, resource_name='resource1', expected={'Value': None})) ] @utils.stack_delete_after def test_get_attr(self): """Test resolution of get_attr occurrences in HOT template.""" self.stack = parser.Stack(self.ctx, 'test_get_attr', template.Template(self.hot_tpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) rsrc = self.stack[self.resource_name] for action, status in ( (rsrc.CREATE, rsrc.IN_PROGRESS), (rsrc.CREATE, rsrc.COMPLETE), (rsrc.RESUME, rsrc.IN_PROGRESS), (rsrc.RESUME, rsrc.COMPLETE), (rsrc.UPDATE, rsrc.IN_PROGRESS), (rsrc.UPDATE, rsrc.COMPLETE)): rsrc.state_set(action, status) resolved = function.resolve(self.stack.t.parse(self.stack, self.snippet)) self.assertEqual(self.expected, resolved) class StackGetAttrValidationTest(HeatTestCase): def setUp(self): super(StackGetAttrValidationTest, self).setUp() self.ctx = utils.dummy_context() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) resource._register_class('ResWithComplexPropsAndAttrsType', generic_rsrc.ResWithComplexPropsAndAttrs) def test_validate_props_from_attrs(self): stack = parser.Stack(self.ctx, 'test_props_from_attrs', template.Template(hot_tpl_mapped_props)) stack.resources['resource1'].list = None stack.resources['resource1'].map = None stack.resources['resource1'].string = None try: stack.validate() except exception.StackValidationFailed as exc: self.fail("Validation should have passed: %s" % str(exc)) self.assertEqual([], stack.resources['resource2'].properties['a_list']) self.assertEqual({}, stack.resources['resource2'].properties['a_map']) self.assertEqual('', stack.resources['resource2'].properties['a_string']) class StackParametersTest(HeatTestCase): """ Test stack get_param function when stack was created from HOT template. """ scenarios = [ ('Ref_string', dict(params={'foo': 'bar', 'blarg': 'wibble'}, snippet={'properties': {'prop1': {'Ref': 'foo'}, 'prop2': {'Ref': 'blarg'}}}, expected={'properties': {'prop1': 'bar', 'prop2': 'wibble'}})), ('get_param_string', dict(params={'foo': 'bar', 'blarg': 'wibble'}, snippet={'properties': {'prop1': {'get_param': 'foo'}, 'prop2': {'get_param': 'blarg'}}}, expected={'properties': {'prop1': 'bar', 'prop2': 'wibble'}})), ('get_list_attr', dict(params={'list': 'foo,bar'}, snippet={'properties': {'prop1': {'get_param': ['list', 1]}}}, expected={'properties': {'prop1': 'bar'}})), ('get_flat_dict_attr', dict(params={'flat_dict': {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}}, snippet={'properties': {'prop1': {'get_param': ['flat_dict', 'key2']}}}, expected={'properties': {'prop1': 'val2'}})), ('get_nested_attr_list', dict(params={'nested_dict': {'list': [1, 2, 3], 'string': 'abc', 'dict': {'a': 1, 'b': 2, 'c': 3}}}, snippet={'properties': {'prop1': {'get_param': ['nested_dict', 'list', 0]}}}, expected={'properties': {'prop1': 1}})), ('get_nested_attr_dict', dict(params={'nested_dict': {'list': [1, 2, 3], 'string': 'abc', 'dict': {'a': 1, 'b': 2, 'c': 3}}}, snippet={'properties': {'prop1': {'get_param': ['nested_dict', 'dict', 'a']}}}, expected={'properties': {'prop1': 1}})), ('get_attr_none', dict(params={'none': None}, snippet={'properties': {'prop1': {'get_param': ['none', 'who_cares']}}}, expected={'properties': {'prop1': ''}})), ] props_template = template_format.parse(''' heat_template_version: 2013-05-23 parameters: foo: type: string default: '' blarg: type: string default: '' list: type: comma_delimited_list default: '' flat_dict: type: json default: {} nested_dict: type: json default: {} none: type: string default: 'default' ''') def test_param_refs(self): """Test if parameter references work.""" tmpl = parser.Template(self.props_template) env = environment.Environment(self.params) stack = parser.Stack(utils.dummy_context(), 'test', tmpl, env) self.assertEqual(self.expected, function.resolve(tmpl.parse(stack, self.snippet))) class HOTParamValidatorTest(HeatTestCase): """Test HOTParamValidator""" def test_multiple_constraint_descriptions(self): len_desc = 'string length should be between 8 and 16' pattern_desc1 = 'Value must consist of characters only' pattern_desc2 = 'Value must start with a lowercase character' param = { 'db_name': { 'description': 'The WordPress database name', 'type': 'string', 'default': 'wordpress', 'constraints': [ {'length': {'min': 6, 'max': 16}, 'description': len_desc}, {'allowed_pattern': '[a-zA-Z]+', 'description': pattern_desc1}, {'allowed_pattern': '[a-z]+[a-zA-Z]*', 'description': pattern_desc2}]}} name = 'db_name' schema = param['db_name'] def v(value): param_schema = hot_param.HOTParamSchema.from_dict(schema) param_schema.validate() param_schema.validate_value(name, value) return True value = 'wp' err = self.assertRaises(ValueError, v, value) self.assertIn(len_desc, str(err)) value = 'abcdefghijklmnopq' err = self.assertRaises(ValueError, v, value) self.assertIn(len_desc, str(err)) value = 'abcdefgh1' err = self.assertRaises(ValueError, v, value) self.assertIn(pattern_desc1, str(err)) value = 'Abcdefghi' err = self.assertRaises(ValueError, v, value) self.assertIn(pattern_desc2, str(err)) value = 'abcdefghi' self.assertTrue(v(value)) value = 'abcdefghI' self.assertTrue(v(value)) def test_hot_template_validate_param(self): len_desc = 'string length should be between 8 and 16' pattern_desc1 = 'Value must consist of characters only' pattern_desc2 = 'Value must start with a lowercase character' hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: db_name: description: The WordPress database name type: string default: wordpress constraints: - length: { min: 8, max: 16 } description: %s - allowed_pattern: "[a-zA-Z]+" description: %s - allowed_pattern: "[a-z]+[a-zA-Z]*" description: %s ''' % (len_desc, pattern_desc1, pattern_desc2)) tmpl = parser.Template(hot_tpl) def run_parameters(value): tmpl.parameters( identifier.HeatIdentifier('', "stack_testit", None), {'db_name': value}).validate(validate_value=True) return True value = 'wp' err = self.assertRaises(ValueError, run_parameters, value) self.assertIn(len_desc, str(err)) value = 'abcdefghijklmnopq' err = self.assertRaises(ValueError, run_parameters, value) self.assertIn(len_desc, str(err)) value = 'abcdefgh1' err = self.assertRaises(ValueError, run_parameters, value) self.assertIn(pattern_desc1, str(err)) value = 'Abcdefghi' err = self.assertRaises(ValueError, run_parameters, value) self.assertIn(pattern_desc2, str(err)) value = 'abcdefghi' self.assertTrue(run_parameters(value)) value = 'abcdefghI' self.assertTrue(run_parameters(value)) def test_range_constraint(self): range_desc = 'Value must be between 30000 and 50000' param = { 'db_port': { 'description': 'The database port', 'type': 'number', 'default': 31000, 'constraints': [ {'range': {'min': 30000, 'max': 50000}, 'description': range_desc}]}} name = 'db_port' schema = param['db_port'] def v(value): param_schema = hot_param.HOTParamSchema.from_dict(schema) param_schema.validate() param_schema.validate_value(name, value) return True value = 29999 err = self.assertRaises(ValueError, v, value) self.assertIn(range_desc, str(err)) value = 50001 err = self.assertRaises(ValueError, v, value) self.assertIn(range_desc, str(err)) value = 30000 self.assertTrue(v(value)) value = 40000 self.assertTrue(v(value)) value = 50000 self.assertTrue(v(value)) def test_custom_constraint(self): class ZeroConstraint(object): def validate(self, value, context): return value == "0" env = resources.global_env() env.register_constraint("zero", ZeroConstraint) self.addCleanup(env.constraints.pop, "zero") desc = 'Value must be zero' param = { 'param1': { 'type': 'string', 'constraints': [ {'custom_constraint': 'zero', 'description': desc}]}} name = 'param1' schema = param['param1'] def v(value): param_schema = hot_param.HOTParamSchema.from_dict(schema) param_schema.validate() param_schema.validate_value(name, value) return True value = "1" err = self.assertRaises(ValueError, v, value) self.assertEqual(desc, str(err)) value = "2" err = self.assertRaises(ValueError, v, value) self.assertEqual(desc, str(err)) value = "0" self.assertTrue(v(value)) def test_range_constraint_invalid_default(self): range_desc = 'Value must be between 30000 and 50000' param = { 'db_port': { 'description': 'The database port', 'type': 'number', 'default': 15, 'constraints': [ {'range': {'min': 30000, 'max': 50000}, 'description': range_desc}]}} schema = hot_param.HOTParamSchema.from_dict(param['db_port']) err = self.assertRaises(constraints.InvalidSchemaError, schema.validate) self.assertIn(range_desc, str(err)) def test_validate_schema_wrong_key(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: foo: bar ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual("Invalid key 'foo' for parameter", str(error)) def test_validate_schema_no_type(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: description: Hi! ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual("Missing parameter type", str(error)) def test_validate_schema_unknown_type(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: Unicode ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid type (Unicode)", str(error)) def test_validate_schema_constraints(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: - allowed_valus: [foo, bar] default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid key 'allowed_valus' for parameter constraints", str(error)) def test_validate_schema_constraints_not_list(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: 1 default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid parameter constraints, expected a list", str(error)) def test_validate_schema_constraints_not_mapping(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: [foo] default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid parameter constraints, expected a mapping", str(error)) def test_validate_schema_empty_constraints(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: - description: a constraint default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual("No constraint expressed", str(error)) def test_validate_schema_constraints_range_wrong_format(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: number constraints: - range: foo default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid range constraint, expected a mapping", str(error)) def test_validate_schema_constraints_range_invalid_key(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: number constraints: - range: {min: 1, foo: bar} default: 1 ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid key 'foo' for range constraint", str(error)) def test_validate_schema_constraints_length_wrong_format(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: - length: foo default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid length constraint, expected a mapping", str(error)) def test_validate_schema_constraints_length_invalid_key(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: - length: {min: 1, foo: bar} default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "Invalid key 'foo' for length constraint", str(error)) def test_validate_schema_constraints_wrong_allowed_pattern(self): hot_tpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: param1: type: string constraints: - allowed_pattern: [foo, bar] default: foo ''') error = self.assertRaises( constraints.InvalidSchemaError, parameters.Parameters, "stack_testit", parser.Template(hot_tpl)) self.assertEqual( "AllowedPattern must be a string", str(error)) heat-2014.1.5/heat/tests/test_attributes.py0000664000567000056700000000712612540642614021721 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. from heat.engine import attributes from heat.tests import common class AttributeTest(common.HeatTestCase): """Test the Attribute class.""" def test_as_output(self): """Test that Attribute looks right when viewed as an Output.""" expected = { "Value": '{"Fn::GetAtt": ["test_resource", "test1"]}', "Description": "The first test attribute" } attr = attributes.Attribute("test1", "The first test attribute") self.assertEqual(expected, attr.as_output("test_resource")) class AttributesTest(common.HeatTestCase): """Test the Attributes class.""" attributes_schema = { "test1": "Test attrib 1", "test2": "Test attrib 2", "test3": "Test attrib 3" } def setUp(self): super(AttributesTest, self).setUp() self.addCleanup(self.m.VerifyAll) def test_get_attribute(self): """Test that we get the attribute values we expect.""" test_resolver = lambda x: "value1" self.m.ReplayAll() attribs = attributes.Attributes('test resource', self.attributes_schema, test_resolver) self.assertEqual("value1", attribs['test1']) def test_get_attribute_none(self): """Test that we get the attribute values we expect.""" test_resolver = lambda x: None self.m.ReplayAll() attribs = attributes.Attributes('test resource', self.attributes_schema, test_resolver) self.assertIsNone(attribs['test1']) def test_get_attribute_nonexist(self): """Test that we get the attribute values we expect.""" test_resolver = lambda x: "value1" self.m.ReplayAll() attribs = attributes.Attributes('test resource', self.attributes_schema, test_resolver) self.assertRaises(KeyError, attribs.__getitem__, 'not there') def test_as_outputs(self): """Test that Output format works as expected.""" expected = { "test1": { "Value": '{"Fn::GetAtt": ["test_resource", "test1"]}', "Description": "Test attrib 1" }, "test2": { "Value": '{"Fn::GetAtt": ["test_resource", "test2"]}', "Description": "Test attrib 2" }, "test3": { "Value": '{"Fn::GetAtt": ["test_resource", "test3"]}', "Description": "Test attrib 3" } } MyTestResourceClass = self.m.CreateMockAnything() MyTestResourceClass.attributes_schema = { "test1": "Test attrib 1", "test2": "Test attrib 2", "test3": "Test attrib 3" } self.m.ReplayAll() self.assertEqual( expected, attributes.Attributes.as_outputs("test_resource", MyTestResourceClass)) heat-2014.1.5/heat/tests/test_stack_resource.py0000664000567000056700000005732112540642614022551 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. import uuid import mock import mox from heat.common import exception from heat.common import template_format from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.engine import stack_resource from heat.tests.common import HeatTestCase from heat.tests import generic_resource as generic_rsrc from heat.tests import utils ws_res_snippet = {"Type": "some_magic_type", "metadata": { "key": "value", "some": "more stuff"}} param_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "WebServer": { "Type": "GenericResource", "Properties": {} } } } ''' simple_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Parameters" : {}, "Resources" : { "WebServer": { "Type": "GenericResource", "Properties": {} } } } ''' class MyStackResource(stack_resource.StackResource, generic_rsrc.GenericResource): def physical_resource_name(self): return "cb2f2b28-a663-4683-802c-4b40c916e1ff" def set_template(self, nested_template, params): self.nested_template = nested_template self.nested_params = params def handle_create(self): return self.create_with_template(self.nested_template, self.nested_params) def handle_adopt(self, resource_data): return self.create_with_template(self.nested_template, self.nested_params, adopt_data=resource_data) def handle_delete(self): self.delete_nested() class MyImplementedStackResource(MyStackResource): def child_template(self): return self.nested_template def child_params(self): return self.nested_params class StackResourceTest(HeatTestCase): def setUp(self): super(StackResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('some_magic_type', MyStackResource) resource._register_class('GenericResource', generic_rsrc.GenericResource) t = parser.Template({'Resources': {"provider_resource": ws_res_snippet}}) self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack', t, stack_id=str(uuid.uuid4())) self.parent_resource = MyStackResource('test', ws_res_snippet, self.parent_stack) self.templ = template_format.parse(param_template) self.simple_template = template_format.parse(simple_template) def test_child_template_defaults_to_not_implemented(self): self.assertRaises(NotImplementedError, self.parent_resource.child_template) def test_child_params_defaults_to_not_implemented(self): self.assertRaises(NotImplementedError, self.parent_resource.child_params) def test_preview_defaults_to_stack_resource_itself(self): preview = self.parent_resource.preview() self.assertIsInstance(preview, stack_resource.StackResource) def test_propagated_files(self): self.parent_stack.t.files["foo"] = "bar" self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.assertEqual({"foo": "bar"}, self.stack.t.files) @mock.patch.object(stack_resource.StackResource, '_nested_environment') @mock.patch.object(stack_resource.parser, 'Template') @mock.patch.object(stack_resource.parser, 'Stack') def test_preview_with_implemented_child_resource(self, mock_stack_class, mock_template_class, mock_env_class): nested_stack = mock.Mock() mock_stack_class.return_value = nested_stack nested_stack.preview_resources.return_value = 'preview_nested_stack' mock_template_class.return_value = 'parsed_template' mock_env_class.return_value = 'environment' template = template_format.parse(param_template) parent_resource = MyImplementedStackResource('test', ws_res_snippet, self.parent_stack) params = {'KeyName': 'test'} parent_resource.set_template(template, params) validation_mock = mock.Mock(return_value=None) parent_resource._validate_nested_resources = validation_mock result = parent_resource.preview() mock_env_class.assert_called_once_with(params) mock_template_class.assert_called_once_with(template) self.assertEqual('preview_nested_stack', result) mock_stack_class.assert_called_once_with( mock.ANY, 'test_stack-test', 'parsed_template', 'environment', disable_rollback=mock.ANY, parent_resource=parent_resource, owner_id=mock.ANY ) def test_preview_validates_nested_resources(self): stack_resource = MyImplementedStackResource('test', ws_res_snippet, self.parent_stack) stack_resource.child_template = mock.Mock(return_value={}) stack_resource.child_params = mock.Mock() exc = exception.RequestLimitExceeded(message='Validation Failed') validation_mock = mock.Mock(side_effect=exc) stack_resource._validate_nested_resources = validation_mock self.assertRaises(exception.RequestLimitExceeded, stack_resource.preview) def test__validate_nested_resources_checks_num_of_resources(self): stack_resource.cfg.CONF.set_override('max_resources_per_stack', 2) tmpl = {'Resources': [1]} template = stack_resource.parser.Template(tmpl) root_resources = mock.Mock(return_value=2) self.parent_resource.stack.root_stack.total_resources = root_resources self.assertRaises(exception.RequestLimitExceeded, self.parent_resource._validate_nested_resources, template) @utils.stack_delete_after def test_create_with_template_ok(self): self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.assertEqual(self.parent_resource, self.stack.parent_resource) self.assertEqual("cb2f2b28-a663-4683-802c-4b40c916e1ff", self.stack.name) self.assertEqual(self.templ, self.stack.t.t) self.assertEqual(self.stack.id, self.parent_resource.resource_id) self.assertIsNone(self.stack.timeout_mins) @utils.stack_delete_after def test_create_with_template_timeout_mins(self): self.assertIsNone(self.parent_stack.timeout_mins) self.m.StubOutWithMock(self.parent_stack, 'timeout_mins') self.parent_stack.timeout_mins = 100 self.m.ReplayAll() self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.assertEqual(100, self.stack.timeout_mins) self.m.VerifyAll() @utils.stack_delete_after def test_adopt_with_template_ok(self): adopt_data = { "resources": { "WebServer": { "resource_id": "test-res-id" } } } self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}, adopt_data=adopt_data) self.stack = self.parent_resource.nested() self.assertEqual(self.stack.ADOPT, self.stack.action) self.assertEqual('test-res-id', self.stack.resources['WebServer'].resource_id) self.assertEqual(self.parent_resource, self.stack.parent_resource) self.assertEqual("cb2f2b28-a663-4683-802c-4b40c916e1ff", self.stack.name) self.assertEqual(self.templ, self.stack.t.t) self.assertEqual(self.stack.id, self.parent_resource.resource_id) @utils.stack_delete_after def test_set_deletion_policy(self): self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.parent_resource.set_deletion_policy(resource.RETAIN) for res in self.stack.resources.values(): self.assertEqual(resource.RETAIN, res.t['DeletionPolicy']) @utils.stack_delete_after def test_get_abandon_data(self): self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) ret = self.parent_resource.get_abandon_data() # check abandoned data contains all the necessary information. # (no need to check stack/resource IDs, because they are # randomly generated uuids) self.assertEqual(6, len(ret)) self.assertEqual('CREATE', ret['action']) self.assertIn('name', ret) self.assertIn('id', ret) self.assertIn('resources', ret) self.assertEqual(template_format.parse(param_template), ret['template']) @utils.stack_delete_after def test_create_with_template_validates(self): """ Creating a stack with a template validates the created stack, so that an invalid template will cause an error to be raised. """ # Make a parameter key with the same name as the resource to cause a # simple validation error template = self.simple_template.copy() template['Parameters']['WebServer'] = {'Type': 'String'} self.assertRaises( exception.StackValidationFailed, self.parent_resource.create_with_template, template, {'WebServer': 'foo'}) @utils.stack_delete_after def test_update_with_template_validates(self): """Updating a stack with a template validates the created stack.""" create_result = self.parent_resource.create_with_template( self.simple_template, {}) while not create_result.step(): pass template = self.simple_template.copy() template['Parameters']['WebServer'] = {'Type': 'String'} self.assertRaises( exception.StackValidationFailed, self.parent_resource.update_with_template, template, {'WebServer': 'foo'}) @utils.stack_delete_after def test_update_with_template_ok(self): """ The update_with_template method updates the nested stack with the given template and user parameters. """ create_result = self.parent_resource.create_with_template( self.simple_template, {}) while not create_result.step(): pass self.stack = self.parent_resource.nested() new_templ = self.simple_template.copy() inst_snippet = new_templ["Resources"]["WebServer"].copy() new_templ["Resources"]["WebServer2"] = inst_snippet updater = self.parent_resource.update_with_template( new_templ, {}) updater.run_to_completion() self.assertIs(True, self.parent_resource.check_update_complete(updater)) self.assertEqual(('UPDATE', 'COMPLETE'), self.stack.state) self.assertEqual(set(["WebServer", "WebServer2"]), set(self.stack.keys())) self.assertIsNone(self.stack.timeout_mins) # The stack's owner_id is maintained. saved_stack = parser.Stack.load( self.parent_stack.context, self.stack.id) self.assertEqual(self.parent_stack.id, saved_stack.owner_id) @utils.stack_delete_after def test_update_with_template_timeout_mins(self): self.assertIsNone(self.parent_stack.timeout_mins) self.m.StubOutWithMock(self.parent_stack, 'timeout_mins') self.parent_stack.timeout_mins = 100 self.m.ReplayAll() create_result = self.parent_resource.create_with_template( self.simple_template, {}) while not create_result.step(): pass self.stack = self.parent_resource.nested() self.assertEqual(100, self.stack.timeout_mins) self.parent_stack.timeout_mins = 200 self.m.ReplayAll() updater = self.parent_resource.update_with_template( self.simple_template, {}) updater.run_to_completion() self.assertEqual(200, self.stack.timeout_mins) self.m.VerifyAll() @utils.stack_delete_after def test_update_with_template_files(self): create_result = self.parent_resource.create_with_template( self.simple_template, {}) while not create_result.step(): pass self.stack = self.parent_resource.nested() new_templ = self.simple_template.copy() inst_snippet = new_templ["Resources"]["WebServer"].copy() new_templ["Resources"]["WebServer2"] = inst_snippet self.parent_stack.t.files["foo"] = "bar" updater = self.parent_resource.update_with_template( new_templ, {}) updater.run_to_completion() self.assertEqual({"foo": "bar"}, self.stack.t.files) @utils.stack_delete_after def test_update_with_template_state_err(self): """ update_with_template_state_err method should raise error when update task is done but the nested stack is in (UPDATE, FAILED) state. """ create_creator = self.parent_resource.create_with_template( self.simple_template, {}) create_creator.run_to_completion() self.stack = self.parent_resource.nested() new_templ = self.simple_template.copy() inst_snippet = new_templ["Resources"]["WebServer"].copy() new_templ["Resources"]["WebServer2"] = inst_snippet def update_task(): yield self.stack.state_set(parser.Stack.UPDATE, parser.Stack.FAILED, '') self.m.StubOutWithMock(self.stack, 'update_task') self.stack.update_task(mox.IgnoreArg()).AndReturn(update_task()) self.m.ReplayAll() updater = self.parent_resource.update_with_template(new_templ, {}) updater.run_to_completion() self.assertEqual((self.stack.UPDATE, self.stack.FAILED), self.stack.state) ex = self.assertRaises(exception.Error, self.parent_resource.check_update_complete, updater) self.assertEqual('Nested stack UPDATE failed: ', str(ex)) self.m.VerifyAll() @utils.stack_delete_after def test_load_nested_ok(self): self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.parent_resource._nested = None self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.parent_resource.context, self.parent_resource.resource_id, parent_resource=self.parent_resource, show_deleted=False).AndReturn('s') self.m.ReplayAll() self.parent_resource.nested() self.m.VerifyAll() @utils.stack_delete_after def test_load_nested_non_exist(self): self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.parent_resource._nested = None self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.parent_resource.context, self.parent_resource.resource_id, parent_resource=self.parent_resource, show_deleted=False) self.m.ReplayAll() self.assertRaises(exception.NotFound, self.parent_resource.nested) self.m.VerifyAll() def test_delete_nested_ok(self): nested = self.m.CreateMockAnything() self.m.StubOutWithMock(stack_resource.StackResource, 'nested') stack_resource.StackResource.nested().AndReturn(nested) nested.delete() self.m.ReplayAll() self.parent_resource.delete_nested() self.m.VerifyAll() def test_delete_nested_not_found_nested_stack(self): self.parent_resource.create_with_template(self.templ, {"KeyName": "key"}) self.stack = self.parent_resource.nested() self.parent_resource._nested = None self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load( self.parent_resource.context, self.parent_resource.resource_id, parent_resource=self.parent_resource, show_deleted=False).AndRaise(exception.NotFound('')) self.m.ReplayAll() self.assertIsNone(self.parent_resource.delete_nested()) def test_get_output_ok(self): nested = self.m.CreateMockAnything() self.m.StubOutWithMock(stack_resource.StackResource, 'nested') stack_resource.StackResource.nested().AndReturn(nested) nested.outputs = {"key": "value"} nested.output('key').AndReturn("value") self.m.ReplayAll() self.assertEqual("value", self.parent_resource.get_output("key")) self.m.VerifyAll() def test_get_output_key_not_found(self): nested = self.m.CreateMockAnything() self.m.StubOutWithMock(stack_resource.StackResource, 'nested') stack_resource.StackResource.nested().AndReturn(nested) nested.outputs = {} self.m.ReplayAll() self.assertRaises(exception.InvalidTemplateAttribute, self.parent_resource.get_output, "key") self.m.VerifyAll() @utils.stack_delete_after def test_create_complete_state_err(self): """ check_create_complete should raise error when create task is done but the nested stack is not in (CREATE,COMPLETE) state """ del self.templ['Resources']['WebServer'] self.parent_resource.set_template(self.templ, {"KeyName": "test"}) ctx = self.parent_resource.context phy_id = "cb2f2b28-a663-4683-802c-4b40c916e1ff" templ = parser.Template(self.templ) env = environment.Environment({"KeyName": "test"}) self.stack = parser.Stack(ctx, phy_id, templ, env, timeout_mins=None, disable_rollback=True, parent_resource=self.parent_resource) self.m.StubOutWithMock(parser, 'Template') parser.Template(self.templ, files={}).AndReturn(templ) self.m.StubOutWithMock(environment, 'Environment') environment.Environment().AndReturn(env) self.m.StubOutWithMock(parser, 'Stack') parser.Stack(ctx, phy_id, templ, env, timeout_mins=None, disable_rollback=True, parent_resource=self.parent_resource, owner_id=self.parent_stack.id, adopt_stack_data=None).AndReturn(self.stack) st_set = self.stack.state_set self.m.StubOutWithMock(self.stack, 'state_set') self.stack.state_set(self.stack.CREATE, self.stack.IN_PROGRESS, "Stack CREATE started").WithSideEffects(st_set) self.stack.state_set(self.stack.CREATE, self.stack.COMPLETE, "Stack CREATE completed successfully") self.m.ReplayAll() self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(self.parent_resource.create)) self.assertEqual(('CREATE', 'FAILED'), self.parent_resource.state) self.assertEqual(('Error: Stack CREATE started'), self.parent_resource.status_reason) self.m.VerifyAll() # Restore state_set to let clean up proceed self.stack.state_set = st_set @utils.stack_delete_after def test_suspend_complete_state_err(self): """ check_suspend_complete should raise error when suspend task is done but the nested stack is not in (SUSPEND,COMPLETE) state """ del self.templ['Resources']['WebServer'] self.parent_resource.set_template(self.templ, {"KeyName": "test"}) scheduler.TaskRunner(self.parent_resource.create)() self.stack = self.parent_resource.nested() st_set = self.stack.state_set self.m.StubOutWithMock(self.stack, 'state_set') self.stack.state_set(parser.Stack.SUSPEND, parser.Stack.IN_PROGRESS, "Stack SUSPEND started").WithSideEffects(st_set) self.stack.state_set(parser.Stack.SUSPEND, parser.Stack.COMPLETE, "Stack SUSPEND completed successfully") self.m.ReplayAll() self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(self.parent_resource.suspend)) self.assertEqual(('SUSPEND', 'FAILED'), self.parent_resource.state) self.assertEqual(('Error: Stack SUSPEND started'), self.parent_resource.status_reason) self.m.VerifyAll() # Restore state_set to let clean up proceed self.stack.state_set = st_set @utils.stack_delete_after def test_resume_complete_state_err(self): """ check_resume_complete should raise error when resume task is done but the nested stack is not in (RESUME,COMPLETE) state """ del self.templ['Resources']['WebServer'] self.parent_resource.set_template(self.templ, {"KeyName": "test"}) scheduler.TaskRunner(self.parent_resource.create)() self.stack = self.parent_resource.nested() scheduler.TaskRunner(self.parent_resource.suspend)() st_set = self.stack.state_set self.m.StubOutWithMock(self.stack, 'state_set') self.stack.state_set(parser.Stack.RESUME, parser.Stack.IN_PROGRESS, "Stack RESUME started").WithSideEffects(st_set) self.stack.state_set(parser.Stack.RESUME, parser.Stack.COMPLETE, "Stack RESUME completed successfully") self.m.ReplayAll() self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(self.parent_resource.resume)) self.assertEqual(('RESUME', 'FAILED'), self.parent_resource.state) self.assertEqual(('Error: Stack RESUME started'), self.parent_resource.status_reason) self.m.VerifyAll() # Restore state_set to let clean up proceed self.stack.state_set = st_set heat-2014.1.5/heat/tests/test_volume.py0000664000567000056700000012076112540642614021043 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. import copy import json from cinderclient.v1 import client as cinderclient import mox from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import resource from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import nova_utils from heat.engine.resources import volume as vol from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes volume_backups = try_import('cinderclient.v1.volume_backups') volume_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Volume Test", "Parameters" : {}, "Resources" : { "WikiDatabase": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "some data" } }, "DataVolume" : { "Type" : "AWS::EC2::Volume", "Properties" : { "Size" : "1", "AvailabilityZone" : {"Fn::GetAtt": ["WikiDatabase", "AvailabilityZone"]}, "Tags" : [{ "Key" : "Usage", "Value" : "Wiki Data Volume" }] } }, "DataVolume2" : { "Type" : "AWS::EC2::Volume", "Properties" : { "Size" : "2", "AvailabilityZone" : {"Fn::GetAtt": ["WikiDatabase", "AvailabilityZone"]}, "Tags" : [{ "Key" : "Usage", "Value" : "Wiki Data Volume2" }] } }, "MountPoint" : { "Type" : "AWS::EC2::VolumeAttachment", "Properties" : { "InstanceId" : { "Ref" : "WikiDatabase" }, "VolumeId" : { "Ref" : "DataVolume" }, "Device" : "/dev/vdc" } } } } ''' class VolumeTest(HeatTestCase): def setUp(self): super(VolumeTest, self).setUp() self.fc = fakes.FakeClient() self.cinder_fc = cinderclient.Client('username', 'password') self.m.StubOutWithMock(clients.OpenStackClients, 'cinder') self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(self.cinder_fc.volumes, 'create') self.m.StubOutWithMock(self.cinder_fc.volumes, 'get') self.m.StubOutWithMock(self.cinder_fc.volumes, 'delete') self.m.StubOutWithMock(self.fc.volumes, 'create_server_volume') self.m.StubOutWithMock(self.fc.volumes, 'delete_server_volume') self.m.StubOutWithMock(self.fc.volumes, 'get_server_volume') self.m.StubOutWithMock(nova_utils, 'get_image_id') utils.setup_dummy_db() def create_volume(self, t, stack, resource_name): data = t['Resources'][resource_name] data['Properties']['AvailabilityZone'] = 'nova' rsrc = vol.Volume(resource_name, data, stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def create_attachment(self, t, stack, resource_name): rsrc = vol.VolumeAttachment(resource_name, t['Resources'][resource_name], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def _mock_create_volume(self, fv, stack_name): clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) vol_name = utils.PhysName(stack_name, 'DataVolume') self.cinder_fc.volumes.create( size=1, availability_zone='nova', display_description=vol_name, display_name=vol_name, metadata={u'Usage': u'Wiki Data Volume'}).AndReturn(fv) def _stubout_delete_volume(self, fv): self.m.StubOutWithMock(fv, 'delete') fv.delete().AndReturn(True) self.m.StubOutWithMock(fv, 'get') fv.get().AndReturn(None) fv.get().AndRaise( clients.cinderclient.exceptions.NotFound('Not found')) self.m.ReplayAll() def _mock_create_server_volume_script(self, fva, server=u'WikiDatabase', volume='vol-123', device=u'/dev/vdc', update=False): if not update: clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.fc.volumes.create_server_volume( device=device, server_id=server, volume_id=volume).AndReturn(fva) self.cinder_fc.volumes.get(volume).AndReturn(fva) def test_volume(self): fv = FakeVolume('creating', 'available') stack_name = 'test_volume_stack' # create script self._mock_create_volume(fv, stack_name) # delete script self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) stack = utils.parse_stack(t, stack_name=stack_name) rsrc = self.create_volume(t, stack, 'DataVolume') self.assertEqual('available', fv.status) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) fv.status = 'in-use' self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.destroy)) self._stubout_delete_volume(fv) fv.status = 'available' scheduler.TaskRunner(rsrc.destroy)() # Test when volume already deleted rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.destroy)() self.m.VerifyAll() def test_volume_default_az(self): fv = FakeVolume('creating', 'available') stack_name = 'test_volume_stack' # create script clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') self.m.StubOutWithMock(vol.VolumeAttachment, 'handle_create') self.m.StubOutWithMock(vol.VolumeAttachment, 'check_create_complete') self.m.StubOutWithMock(image.ImageConstraint, "validate") instance.Instance.handle_create().AndReturn(None) instance.Instance.check_create_complete(None).AndReturn(True) clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) vol_name = utils.PhysName(stack_name, 'DataVolume') self.cinder_fc.volumes.create( size=1, availability_zone=None, display_description=vol_name, display_name=vol_name, metadata={u'Usage': u'Wiki Data Volume'}).AndReturn(fv) vol.VolumeAttachment.handle_create().AndReturn(None) vol.VolumeAttachment.check_create_complete(None).AndReturn(True) # delete script self.m.StubOutWithMock(instance.Instance, 'handle_delete') self.m.StubOutWithMock(vol.VolumeAttachment, 'handle_delete') instance.Instance.handle_delete().AndReturn(None) self.cinder_fc.volumes.get('vol-123').AndRaise( clients.cinderclient.exceptions.NotFound('Not found')) vol.VolumeAttachment.handle_delete().AndReturn(None) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources'].pop('DataVolume2') stack = utils.parse_stack(t, stack_name=stack_name) rsrc = stack['DataVolume'] self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(stack.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(stack.delete)() self.m.VerifyAll() def test_volume_create_error(self): fv = FakeVolume('creating', 'error') stack_name = 'test_volume_create_error_stack' self._mock_create_volume(fv, stack_name) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.Volume('DataVolume', t['Resources']['DataVolume'], stack) create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self.m.VerifyAll() def test_volume_bad_tags(self): t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['Tags'] = [{'Foo': 'bar'}] stack = utils.parse_stack(t, stack_name='test_volume_bad_tags_stack') rsrc = vol.Volume('DataVolume', t['Resources']['DataVolume'], stack) self.assertRaises(exception.StackValidationFailed, rsrc.validate) self.m.VerifyAll() def test_volume_attachment_error(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'error') stack_name = 'test_volume_attach_error_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = vol.VolumeAttachment('MountPoint', t['Resources']['MountPoint'], stack) create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self.m.VerifyAll() def test_volume_attachment(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'available') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').MultipleTimes().AndReturn(None) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = self.create_attachment(t, stack, 'MountPoint') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_volume_detachment_err(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('in-use', 'available') stack_name = 'test_volume_detach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'available') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.BadRequest('Already detached')) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = self.create_attachment(t, stack, 'MountPoint') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_volume_detach_non_exist(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('in-use', 'available') stack_name = 'test_volume_detach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndRaise( clients.cinderclient.exceptions.NotFound('Not found')) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() rsrc = self.create_attachment(t, stack, 'MountPoint') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_volume_detach_with_latency(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script volume_detach_cycle = 'in-use', 'detaching', 'available' fva = FakeLatencyVolume(life_cycle=volume_detach_cycle) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').MultipleTimes().AndReturn(None) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = self.create_attachment(t, stack, 'MountPoint') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_volume_detach_with_error(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'error') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume('WikiDatabase', 'vol-123').AndReturn(None) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = self.create_attachment(t, stack, 'MountPoint') detach_task = scheduler.TaskRunner(rsrc.delete) self.assertRaises(exception.ResourceFailure, detach_task) self.m.VerifyAll() def test_volume_delete(self): stack_name = 'test_volume_stack' fv = FakeVolume('creating', 'available') self._mock_create_volume(fv, stack_name) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['DeletionPolicy'] = 'Delete' stack = utils.parse_stack(t, stack_name=stack_name) rsrc = self.create_volume(t, stack, 'DataVolume') self.m.StubOutWithMock(rsrc, "handle_delete") rsrc.handle_delete().AndReturn(None) self.m.StubOutWithMock(rsrc, "check_delete_complete") rsrc.check_delete_complete(mox.IgnoreArg()).AndReturn(True) self.m.ReplayAll() scheduler.TaskRunner(rsrc.destroy)() self.m.VerifyAll() def test_volume_attachment_update_device(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') fva2 = FakeVolume('attaching', 'in-use') stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'available') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').MultipleTimes().AndReturn(None) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) # attach script self._mock_create_server_volume_script(fva2, device=u'/dev/vdd', update=True) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = self.create_attachment(t, stack, 'MountPoint') self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) after = copy.deepcopy(t)['Resources']['MountPoint'] after['Properties']['VolumeId'] = 'vol-123' after['Properties']['InstanceId'] = 'WikiDatabase' after['Properties']['Device'] = '/dev/vdd' scheduler.TaskRunner(rsrc.update, after)() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_volume_attachment_update_volume(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') fv2 = FakeVolume('creating', 'available') fv2.id = 'vol-456' fv2a = FakeVolume('attaching', 'in-use') fv2a.id = 'vol-456' stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) vol2_name = utils.PhysName(stack_name, 'DataVolume2') self.cinder_fc.volumes.create( size=2, availability_zone='nova', display_description=vol2_name, display_name=vol2_name, metadata={u'Usage': u'Wiki Data Volume2'}).AndReturn(fv2) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'available') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').MultipleTimes().AndReturn(None) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) # attach script self._mock_create_server_volume_script(fv2a, volume='vol-456', update=True) #self.fc.volumes.create_server_volume( #device=u'/dev/vdc', server_id=u'WikiDatabase', #volume_id='vol-456').AndReturn(fv2a) #self.cinder_fc.volumes.get('vol-456').AndReturn(fv2a) self.m.ReplayAll() t = template_format.parse(volume_template) zone = 'nova' t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = zone t['Resources']['DataVolume2']['Properties']['AvailabilityZone'] = zone stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) scheduler.TaskRunner(stack['DataVolume2'].create)() self.assertEqual('available', fv2.status) rsrc = self.create_attachment(t, stack, 'MountPoint') self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) after = copy.deepcopy(t)['Resources']['MountPoint'] after['Properties']['VolumeId'] = 'vol-456' after['Properties']['InstanceId'] = 'WikiDatabase' scheduler.TaskRunner(rsrc.update, after)() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) self.assertEqual(fv2a.id, rsrc.resource_id) self.m.VerifyAll() def test_volume_attachment_update_server(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') fva2 = FakeVolume('attaching', 'in-use') stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'available') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').MultipleTimes().AndReturn(None) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) # attach script self._mock_create_server_volume_script(fva2, server=u'WikiDatabase2', update=True) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = self.create_attachment(t, stack, 'MountPoint') self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) after = copy.deepcopy(t)['Resources']['MountPoint'] after['Properties']['VolumeId'] = 'vol-123' after['Properties']['InstanceId'] = 'WikiDatabase2' #after['Properties']['Device'] = '/dev/vdd' scheduler.TaskRunner(rsrc.update, after)() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @skipIf(volume_backups is None, 'unable to import volume_backups') def test_snapshot(self): stack_name = 'test_volume_stack' fv = FakeVolume('creating', 'available') fb = FakeBackup('creating', 'available') self._mock_create_volume(fv, stack_name) # snapshot script self.m.StubOutWithMock(self.cinder_fc.backups, 'create') self.cinder_fc.backups.create('vol-123').AndReturn(fb) self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['DeletionPolicy'] = 'Snapshot' stack = utils.parse_stack(t, stack_name=stack_name) rsrc = self.create_volume(t, stack, 'DataVolume') self._stubout_delete_volume(fv) scheduler.TaskRunner(rsrc.destroy)() self.m.VerifyAll() @skipIf(volume_backups is None, 'unable to import volume_backups') def test_snapshot_error(self): stack_name = 'test_volume_stack' fv = FakeVolume('creating', 'available') fb = FakeBackup('creating', 'error') self._mock_create_volume(fv, stack_name) # snapshot script self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.m.StubOutWithMock(self.cinder_fc.backups, 'create') self.cinder_fc.backups.create('vol-123').AndReturn(fb) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['DeletionPolicy'] = 'Snapshot' stack = utils.parse_stack(t, stack_name=stack_name) rsrc = self.create_volume(t, stack, 'DataVolume') self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.destroy)) self.m.VerifyAll() @skipIf(volume_backups is None, 'unable to import volume_backups') def test_snapshot_no_volume(self): stack_name = 'test_volume_stack' fv = FakeVolume('creating', 'error') self._mock_create_volume(fv, stack_name) self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['DeletionPolicy'] = 'Snapshot' t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.Volume('DataVolume', t['Resources']['DataVolume'], stack) create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self._stubout_delete_volume(fv) scheduler.TaskRunner(rsrc.destroy)() self.m.VerifyAll() @skipIf(volume_backups is None, 'unable to import volume_backups') def test_create_from_snapshot(self): stack_name = 'test_volume_stack' fv = FakeVolumeWithStateTransition('restoring-backup', 'available') fvbr = FakeBackupRestore('vol-123') # create script clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) self.m.StubOutWithMock(self.cinder_fc.restores, 'restore') self.cinder_fc.restores.restore('backup-123').AndReturn(fvbr) self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.m.StubOutWithMock(fv, 'update') vol_name = utils.PhysName(stack_name, 'DataVolume') fv.update( display_description=vol_name, display_name=vol_name) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['SnapshotId'] = 'backup-123' stack = utils.parse_stack(t, stack_name=stack_name) self.create_volume(t, stack, 'DataVolume') self.assertEqual('available', fv.status) self.m.VerifyAll() @skipIf(volume_backups is None, 'unable to import volume_backups') def test_create_from_snapshot_error(self): stack_name = 'test_volume_stack' fv = FakeVolumeWithStateTransition('restoring-backup', 'error') fvbr = FakeBackupRestore('vol-123') # create script clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) self.m.StubOutWithMock(self.cinder_fc.restores, 'restore') self.cinder_fc.restores.restore('backup-123').AndReturn(fvbr) self.cinder_fc.volumes.get('vol-123').AndReturn(fv) self.m.StubOutWithMock(fv, 'update') vol_name = utils.PhysName(stack_name, 'DataVolume') fv.update( display_description=vol_name, display_name=vol_name) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['SnapshotId'] = 'backup-123' t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.Volume('DataVolume', t['Resources']['DataVolume'], stack) create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self.m.VerifyAll() def test_cinder_create(self): fv = FakeVolume('creating', 'available') stack_name = 'test_volume_stack' clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) self.cinder_fc.volumes.create( size=1, availability_zone='nova', display_description='CustomDescription', display_name='CustomName', imageRef='46988116-6703-4623-9dbc-2bc6d284021b', snapshot_id='snap-123', metadata={'key': 'value'}, source_volid='vol-012', volume_type='lvm').AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties'] = { 'size': '1', 'availability_zone': 'nova', 'name': 'CustomName', 'description': 'CustomDescription', 'volume_type': 'lvm', 'metadata': {'key': 'value'}, # Note that specifying all these arguments doesn't work in # practice, as they are conflicting, but we just want to check they # are sent to the backend. 'imageRef': '46988116-6703-4623-9dbc-2bc6d284021b', 'snapshot_id': 'snap-123', 'source_volid': 'vol-012', } stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.CinderVolume('DataVolume', t['Resources']['DataVolume'], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('available', fv.status) self.m.VerifyAll() def test_volume_size_constraint(self): t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties'] = {'size': '0'} stack = utils.parse_stack(t) rsrc = vol.CinderVolume( 'DataVolume', t['Resources']['DataVolume'], stack) error = self.assertRaises(exception.StackValidationFailed, rsrc.validate) self.assertEqual( "Property error : DataVolume: size 0 is out of " "range (min: 1, max: None)", str(error)) def test_cinder_create_from_image(self): fv = FakeVolumeWithStateTransition('downloading', 'available') stack_name = 'test_volume_stack' clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) clients.OpenStackClients.nova("compute").MultipleTimes().AndReturn( self.fc) clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) nova_utils.get_image_id( self.fc, '46988116-6703-4623-9dbc-2bc6d284021b' ).MultipleTimes().AndReturn('46988116-6703-4623-9dbc-2bc6d284021b') self.cinder_fc.volumes.create( size=1, availability_zone='nova', display_description='ImageVolumeDescription', display_name='ImageVolume', imageRef='46988116-6703-4623-9dbc-2bc6d284021b').AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties'] = { 'size': '1', 'name': 'ImageVolume', 'description': 'ImageVolumeDescription', 'availability_zone': 'nova', 'image': '46988116-6703-4623-9dbc-2bc6d284021b', } stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.CinderVolume('DataVolume', t['Resources']['DataVolume'], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('available', fv.status) self.m.VerifyAll() def test_cinder_default(self): fv = FakeVolume('creating', 'available') stack_name = 'test_volume_stack' clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) vol_name = utils.PhysName(stack_name, 'DataVolume') self.cinder_fc.volumes.create( size=1, availability_zone='nova', display_description=None, display_name=vol_name).AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties'] = { 'size': '1', 'availability_zone': 'nova', } stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.CinderVolume('DataVolume', t['Resources']['DataVolume'], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('available', fv.status) self.m.VerifyAll() def test_cinder_fn_getatt(self): fv = FakeVolume('creating', 'available', availability_zone='zone1', size=1, snapshot_id='snap-123', display_name='name', display_description='desc', volume_type='lvm', metadata={'key': 'value'}, source_volid=None, status='available', bootable=False, created_at='2013-02-25T02:40:21.000000') stack_name = 'test_volume_stack' clients.OpenStackClients.cinder().MultipleTimes().AndReturn( self.cinder_fc) vol_name = utils.PhysName(stack_name, 'DataVolume') self.cinder_fc.volumes.create( size=1, availability_zone='nova', display_description=None, display_name=vol_name).AndReturn(fv) self.cinder_fc.volumes.get('vol-123').MultipleTimes().AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties'] = { 'size': '1', 'availability_zone': 'nova', } stack = utils.parse_stack(t, stack_name=stack_name) rsrc = vol.CinderVolume('DataVolume', t['Resources']['DataVolume'], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual(u'zone1', rsrc.FnGetAtt('availability_zone')) self.assertEqual(u'1', rsrc.FnGetAtt('size')) self.assertEqual(u'snap-123', rsrc.FnGetAtt('snapshot_id')) self.assertEqual(u'name', rsrc.FnGetAtt('display_name')) self.assertEqual(u'desc', rsrc.FnGetAtt('display_description')) self.assertEqual(u'lvm', rsrc.FnGetAtt('volume_type')) self.assertEqual(json.dumps({'key': 'value'}), rsrc.FnGetAtt('metadata')) self.assertEqual(u'None', rsrc.FnGetAtt('source_volid')) self.assertEqual(u'available', rsrc.FnGetAtt('status')) self.assertEqual(u'2013-02-25T02:40:21.000000', rsrc.FnGetAtt('created_at')) self.assertEqual(u'False', rsrc.FnGetAtt('bootable')) error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'unknown') self.assertEqual( 'The Referenced Attribute (DataVolume unknown) is incorrect.', str(error)) self.m.VerifyAll() def test_cinder_attachment(self): fv = FakeVolume('creating', 'available') fva = FakeVolume('attaching', 'in-use') stack_name = 'test_volume_attach_stack' self._mock_create_volume(fv, stack_name) self._mock_create_server_volume_script(fva) # delete script fva = FakeVolume('in-use', 'available') self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.cinder_fc.volumes.get(fva.id).AndReturn(fva) self.fc.volumes.delete_server_volume( 'WikiDatabase', 'vol-123').MultipleTimes().AndReturn(None) self.fc.volumes.get_server_volume(u'WikiDatabase', 'vol-123').AndReturn(fva) self.fc.volumes.get_server_volume( u'WikiDatabase', 'vol-123').AndRaise( clients.novaclient.exceptions.NotFound('NotFound')) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' t['Resources']['MountPoint']['Properties'] = { 'instance_uuid': {'Ref': 'WikiDatabase'}, 'volume_id': {'Ref': 'DataVolume'}, 'mountpoint': '/dev/vdc' } stack = utils.parse_stack(t, stack_name=stack_name) scheduler.TaskRunner(stack['DataVolume'].create)() self.assertEqual('available', fv.status) rsrc = vol.CinderVolumeAttachment('MountPoint', t['Resources']['MountPoint'], stack) self.assertIsNone(rsrc.validate()) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() class FakeVolume(object): status = 'attaching' id = 'vol-123' def __init__(self, initial_status, final_status, **attrs): self.status = initial_status self.final_status = final_status for key, value in attrs.iteritems(): setattr(self, key, value) def get(self): self.status = self.final_status def update(self, **kw): pass def delete(self): pass class FakeLatencyVolume(object): status = 'attaching' id = 'vol-123' def __init__(self, life_cycle=('creating', 'available'), **attrs): if not isinstance(life_cycle, tuple): raise exception.Error('life_cycle need to be a tuple.') if not len(life_cycle): raise exception.Error('life_cycle should not be an empty tuple.') self.life_cycle = iter(life_cycle) self.status = next(self.life_cycle) for key, value in attrs.iteritems(): setattr(self, key, value) def get(self): self.status = next(self.life_cycle) def update(self, **kw): pass class FakeBackup(FakeVolume): status = 'creating' id = 'backup-123' class FakeBackupRestore(object): volume_id = 'vol-123' def __init__(self, volume_id): self.volume_id = volume_id class FakeVolumeWithStateTransition(FakeVolume): status = 'restoring-backup' get_call_count = 0 def get(self): # Allow get to be called once without changing the status # This is to allow the check_create_complete method to # check the initial status. if self.get_call_count < 1: self.get_call_count += 1 else: self.status = self.final_status heat-2014.1.5/heat/tests/test_engine_service.py0000664000567000056700000034760512540642614022531 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. import functools import json import sys import uuid from eventlet import greenpool import mock import mox from oslo.config import cfg from heat.common import exception from heat.common import identifier from heat.common import template_format from heat.common import urlfetch import heat.db.api as db_api from heat.engine import clients from heat.engine import dependencies from heat.engine import environment from heat.engine import parser from heat.engine.properties import Properties from heat.engine import resource as res from heat.engine.resources import instance as instances from heat.engine.resources import nova_utils from heat.engine import service from heat.engine import stack_lock from heat.engine import watchrule from heat.openstack.common.fixture import mockpatch from heat.openstack.common.rpc import common as rpc_common from heat.openstack.common.rpc import proxy from heat.openstack.common import threadgroup import heat.rpc.api as engine_api from heat.tests.common import HeatTestCase from heat.tests import fakes as test_fakes from heat.tests import generic_resource as generic_rsrc from heat.tests import utils from heat.tests.v1_1 import fakes cfg.CONF.import_opt('engine_life_check_timeout', 'heat.common.config') wp_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "wordpress" } } } } ''' nested_alarm_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_nested: Type: AWS::CloudFormation::Stack Properties: TemplateURL: https://server.test/alarm.template ''' alarm_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "alarming", "Resources" : { "service_alarm": { "Type": "AWS::CloudWatch::Alarm", "Properties": { "EvaluationPeriods": "1", "AlarmActions": [], "AlarmDescription": "do the thing", "Namespace": "dev/null", "Period": "300", "ComparisonOperator": "GreaterThanThreshold", "Statistic": "SampleCount", "Threshold": "2", "MetricName": "ServiceFailure" } } } } ''' policy_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "alarming", "Resources" : { "WebServerScaleDownPolicy" : { "Type" : "AWS::AutoScaling::ScalingPolicy", "Properties" : { "AdjustmentType" : "ChangeInCapacity", "AutoScalingGroupName" : "", "Cooldown" : "60", "ScalingAdjustment" : "-1" } } } } ''' user_policy_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a User", "Parameters" : {}, "Resources" : { "CfnUser" : { "Type" : "AWS::IAM::User", "Properties" : { "Policies" : [ { "Ref": "WebServerAccessPolicy"} ] } }, "WebServerAccessPolicy" : { "Type" : "OS::Heat::AccessPolicy", "Properties" : { "AllowedResources" : [ "WebServer" ] } }, "HostKeys" : { "Type" : "AWS::IAM::AccessKey", "Properties" : { "UserName" : {"Ref": "CfnUser"} } }, "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "wordpress" } } } } ''' server_config_template = ''' heat_template_version: 2013-05-23 resources: WebServer: type: OS::Nova::Server ''' def get_wordpress_stack(stack_name, ctx): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(ctx, stack_name, template, environment.Environment({'KeyName': 'test'})) return stack def get_stack(stack_name, ctx, template): t = template_format.parse(template) template = parser.Template(t) stack = parser.Stack(ctx, stack_name, template) return stack def setup_keystone_mocks(mocks, stack): fkc = test_fakes.FakeKeystoneClient() mocks.StubOutWithMock(stack.clients, 'keystone') stack.clients.keystone().MultipleTimes().AndReturn(fkc) def setup_mocks(mocks, stack): fc = fakes.FakeClient() mocks.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(fc) mocks.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(fc) setup_keystone_mocks(mocks, stack) instance = stack['WebServer'] user_data = instance.properties['UserData'] server_userdata = nova_utils.build_userdata(instance, user_data, 'ec2-user') mocks.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) mocks.StubOutWithMock(fc.servers, 'create') fc.servers.create(image=744, flavor=3, key_name='test', name=utils.PhysName(stack.name, 'WebServer'), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( fc.servers.list()[4]) return fc def setup_stack(stack_name, ctx, create_res=True): stack = get_wordpress_stack(stack_name, ctx) stack.store() if create_res: m = mox.Mox() setup_mocks(m, stack) m.ReplayAll() stack.create() m.UnsetStubs() return stack def clean_up_stack(stack, delete_res=True): if delete_res: m = mox.Mox() fc = fakes.FakeClient() m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(fc) m.StubOutWithMock(fc.client, 'get_servers_9999') get = fc.client.get_servers_9999 get().AndRaise(service.clients.novaclient.exceptions.NotFound(404)) m.ReplayAll() stack.delete() if delete_res: m.UnsetStubs() def stack_context(stack_name, create_res=True): """ Decorator which creates a stack by using the test case's context and deletes it afterwards to ensure tests clean up their stacks regardless of test success/failure """ def stack_delete(test_fn): @functools.wraps(test_fn) def wrapped_test(test_case, *args, **kwargs): def create_stack(): ctx = getattr(test_case, 'ctx', None) if ctx is not None: stack = setup_stack(stack_name, ctx, create_res) setattr(test_case, 'stack', stack) def delete_stack(): stack = getattr(test_case, 'stack', None) if stack is not None and stack.id is not None: clean_up_stack(stack, delete_res=create_res) create_stack() try: test_fn(test_case, *args, **kwargs) except: exc_class, exc_val, exc_tb = sys.exc_info() try: delete_stack() finally: raise exc_class, exc_val, exc_tb else: delete_stack() return wrapped_test return stack_delete class DummyThreadGroup(object): def __init__(self): self.threads = [] self.pool = greenpool.GreenPool(10) def add_timer(self, interval, callback, initial_delay=None, *args, **kwargs): self.threads.append(callback) def add_thread(self, callback, *args, **kwargs): self.threads.append(callback) return self.pool.spawn(callback, *args, **kwargs) def stop(self): pass def wait(self): pass class StackCreateTest(HeatTestCase): def setUp(self): super(StackCreateTest, self).setUp() utils.setup_dummy_db() def test_wordpress_single_instance_stack_create(self): stack = get_wordpress_stack('test_stack', utils.dummy_context()) setup_mocks(self.m, stack) self.m.ReplayAll() stack.store() stack.create() self.assertIsNotNone(stack['WebServer']) self.assertTrue(stack['WebServer'].resource_id > 0) self.assertNotEqual(stack['WebServer'].ipaddress, '0.0.0.0') def test_wordpress_single_instance_stack_adopt(self): t = template_format.parse(wp_template) template = parser.Template(t) ctx = utils.dummy_context() adopt_data = { 'resources': { 'WebServer': { 'resource_id': 'test-res-id' } } } stack = parser.Stack(ctx, 'test_stack', template, adopt_stack_data=adopt_data) setup_mocks(self.m, stack) self.m.ReplayAll() stack.store() stack.adopt() self.assertIsNotNone(stack['WebServer']) self.assertEqual('test-res-id', stack['WebServer'].resource_id) self.assertEqual((stack.ADOPT, stack.COMPLETE), stack.state) def test_wordpress_single_instance_stack_adopt_fail(self): t = template_format.parse(wp_template) template = parser.Template(t) ctx = utils.dummy_context() adopt_data = { 'resources': { 'WebServer1': { 'resource_id': 'test-res-id' } } } stack = parser.Stack(ctx, 'test_stack', template, adopt_stack_data=adopt_data) setup_mocks(self.m, stack) self.m.ReplayAll() stack.store() stack.adopt() self.assertIsNotNone(stack['WebServer']) expected = ('Resource ADOPT failed: Exception: Resource ID was not' ' provided.') self.assertEqual(expected, stack.status_reason) self.assertEqual((stack.ADOPT, stack.FAILED), stack.state) def test_wordpress_single_instance_stack_delete(self): ctx = utils.dummy_context() stack = get_wordpress_stack('test_stack', ctx) fc = setup_mocks(self.m, stack) self.m.ReplayAll() stack_id = stack.store() stack.create() db_s = db_api.stack_get(ctx, stack_id) self.assertIsNotNone(db_s) self.assertIsNotNone(stack['WebServer']) self.assertTrue(stack['WebServer'].resource_id > 0) self.m.StubOutWithMock(fc.client, 'get_servers_9999') get = fc.client.get_servers_9999 get().AndRaise(service.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) stack.delete() rsrc = stack['WebServer'] self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.assertEqual((stack.DELETE, stack.COMPLETE), rsrc.state) self.assertIsNone(db_api.stack_get(ctx, stack_id)) self.assertEqual('DELETE', db_s.action) self.assertEqual('COMPLETE', db_s.status, ) class StackServiceCreateUpdateDeleteTest(HeatTestCase): def setUp(self): super(StackServiceCreateUpdateDeleteTest, self).setUp() utils.setup_dummy_db() utils.reset_dummy_db() self.ctx = utils.dummy_context() self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.man = service.EngineService('a-host', 'a-topic') def _test_stack_create(self, stack_name): params = {'foo': 'bar'} template = '{ "Template": "data" }' stack = get_wordpress_stack(stack_name, self.ctx) self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') self.m.StubOutWithMock(parser, 'Stack') parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(self.ctx, stack.name, stack.t, stack.env).AndReturn(stack) self.m.StubOutWithMock(stack, 'validate') stack.validate().AndReturn(None) self.m.StubOutWithMock(threadgroup, 'ThreadGroup') threadgroup.ThreadGroup().AndReturn(DummyThreadGroup()) self.m.ReplayAll() result = self.man.create_stack(self.ctx, stack_name, template, params, None, {}) self.assertEqual(stack.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) self.m.VerifyAll() def test_stack_create(self): stack_name = 'service_create_test_stack' self._test_stack_create(stack_name) def test_stack_create_equals_max_per_tenant(self): cfg.CONF.set_override('max_stacks_per_tenant', 1) stack_name = 'service_create_test_stack_equals_max' self._test_stack_create(stack_name) def test_stack_create_exceeds_max_per_tenant(self): cfg.CONF.set_override('max_stacks_per_tenant', 0) stack_name = 'service_create_test_stack_exceeds_max' ex = self.assertRaises(rpc_common.ClientException, self._test_stack_create, stack_name) self.assertEqual(ex._exc_info[0], exception.RequestLimitExceeded) self.assertIn("You have reached the maximum stacks per tenant", str(ex._exc_info[1])) def test_stack_create_verify_err(self): stack_name = 'service_create_verify_err_test_stack' params = {'foo': 'bar'} template = '{ "Template": "data" }' stack = get_wordpress_stack(stack_name, self.ctx) self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') self.m.StubOutWithMock(parser, 'Stack') parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(self.ctx, stack.name, stack.t, stack.env).AndReturn(stack) self.m.StubOutWithMock(stack, 'validate') stack.validate().AndRaise(exception.StackValidationFailed( message='fubar')) self.m.ReplayAll() ex = self.assertRaises( rpc_common.ClientException, self.man.create_stack, self.ctx, stack_name, template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.StackValidationFailed) self.m.VerifyAll() def test_stack_create_invalid_stack_name(self): stack_name = 'service_create/test_stack' stack = get_wordpress_stack('test_stack', self.ctx) self.assertRaises(ValueError, self.man.create_stack, self.ctx, stack_name, stack.t, {}, None, {}) def test_stack_create_invalid_resource_name(self): stack_name = 'service_create_test_stack_invalid_res' stack = get_wordpress_stack(stack_name, self.ctx) tmpl = dict(stack.t) tmpl['Resources']['Web/Server'] = tmpl['Resources']['WebServer'] del tmpl['Resources']['WebServer'] self.assertRaises(ValueError, self.man.create_stack, self.ctx, stack_name, stack.t, {}, None, {}) def test_stack_create_no_credentials(self): stack_name = 'test_stack_create_no_credentials' params = {'foo': 'bar'} template = '{ "Template": "data" }' stack = get_wordpress_stack(stack_name, self.ctx) # force check for credentials on create stack['WebServer'].requires_deferred_auth = True self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') self.m.StubOutWithMock(parser, 'Stack') ctx_no_pwd = utils.dummy_context(password=None) ctx_no_user = utils.dummy_context(user=None) parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(ctx_no_pwd, stack.name, stack.t, stack.env).AndReturn(stack) parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(ctx_no_user, stack.name, stack.t, stack.env).AndReturn(stack) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.man.create_stack, ctx_no_pwd, stack_name, template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.MissingCredentialError) self.assertEqual( 'Missing required credential: X-Auth-Key', str(ex._exc_info[1])) ex = self.assertRaises(rpc_common.ClientException, self.man.create_stack, ctx_no_user, stack_name, template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.MissingCredentialError) self.assertEqual( 'Missing required credential: X-Auth-User', str(ex._exc_info[1])) def test_stack_create_total_resources_equals_max(self): stack_name = 'service_create_stack_total_resources_equals_max' params = {} res._register_class('GenericResourceType', generic_rsrc.GenericResource) tpl = {'Resources': { 'A': {'Type': 'GenericResourceType'}, 'B': {'Type': 'GenericResourceType'}, 'C': {'Type': 'GenericResourceType'}}} template = parser.Template(tpl) stack = parser.Stack(self.ctx, stack_name, template, environment.Environment({})) self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') self.m.StubOutWithMock(parser, 'Stack') parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(self.ctx, stack.name, stack.t, stack.env).AndReturn(stack) self.m.ReplayAll() cfg.CONF.set_override('max_resources_per_stack', 3) result = self.man.create_stack(self.ctx, stack_name, template, params, None, {}) self.m.VerifyAll() self.assertEqual(stack.identifier(), result) self.assertEqual(3, stack.total_resources()) stack.delete() def test_stack_create_total_resources_exceeds_max(self): stack_name = 'service_create_stack_total_resources_exceeds_max' params = {} res._register_class('GenericResourceType', generic_rsrc.GenericResource) tpl = {'Resources': { 'A': {'Type': 'GenericResourceType'}, 'B': {'Type': 'GenericResourceType'}, 'C': {'Type': 'GenericResourceType'}}} template = parser.Template(tpl) cfg.CONF.set_override('max_resources_per_stack', 2) ex = self.assertRaises(rpc_common.ClientException, self.man.create_stack, self.ctx, stack_name, template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.RequestLimitExceeded) self.assertIn(exception.StackResourceLimitExceeded.msg_fmt, str(ex._exc_info[1])) def test_stack_validate(self): stack_name = 'service_create_test_validate' stack = get_wordpress_stack(stack_name, self.ctx) setup_mocks(self.m, stack) resource = stack['WebServer'] self.m.ReplayAll() resource.properties = Properties( resource.properties_schema, { 'ImageId': 'CentOS 5.2', 'KeyName': 'test', 'InstanceType': 'm1.large' }) stack.validate() resource.properties = Properties( resource.properties_schema, { 'KeyName': 'test', 'InstanceType': 'm1.large' }) self.assertRaises(exception.StackValidationFailed, stack.validate) def test_stack_delete(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() s = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(stack) self.man.tg = DummyThreadGroup() self.m.ReplayAll() self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_stack_delete_nonexist(self): stack_name = 'service_delete_nonexist_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.man.delete_stack, self.ctx, stack.identifier()) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() def test_stack_delete_acquired_lock(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() st = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=st).MultipleTimes().AndReturn(stack) self.man.tg = DummyThreadGroup() self.m.StubOutWithMock(stack_lock.StackLock, 'try_acquire') stack_lock.StackLock.try_acquire().AndReturn(self.man.engine_id) self.m.ReplayAll() self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_stack_delete_acquired_lock_stop_timers(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() st = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=st).MultipleTimes().AndReturn(stack) self.man.tg = DummyThreadGroup() self.m.StubOutWithMock(stack_lock.StackLock, 'try_acquire') stack_lock.StackLock.try_acquire().AndReturn(self.man.engine_id) self.m.ReplayAll() self.man.thread_group_mgr.add_timer(stack.id, 'test') self.assertEqual(1, len(self.man.thread_group_mgr.groups[sid].timers)) self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) self.assertEqual(0, len(self.man.thread_group_mgr.groups[sid].timers)) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_stack_delete_current_engine_active_lock(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() # Insert a fake lock into the db db_api.stack_lock_create(stack.id, self.man.engine_id) # Create a fake ThreadGroup too self.man.thread_group_mgr.groups[stack.id] = DummyThreadGroup() st = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=st).MultipleTimes().AndReturn(stack) self.m.StubOutWithMock(stack_lock.StackLock, 'try_acquire') stack_lock.StackLock.try_acquire().AndReturn(self.man.engine_id) self.m.ReplayAll() self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_stack_delete_other_engine_active_lock_failed(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() # Insert a fake lock into the db db_api.stack_lock_create(stack.id, "other-engine-fake-uuid") st = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=st).AndReturn(stack) self.m.StubOutWithMock(stack_lock.StackLock, 'try_acquire') stack_lock.StackLock.try_acquire().AndReturn("other-engine-fake-uuid") self.m.StubOutWithMock(stack_lock.StackLock, 'engine_alive') stack_lock.StackLock.engine_alive(self.ctx, "other-engine-fake-uuid")\ .AndReturn(True) rpc = proxy.RpcProxy("other-engine-fake-uuid", "1.0") msg = rpc.make_msg("stop_stack", stack_identity=mox.IgnoreArg()) self.m.StubOutWithMock(proxy.RpcProxy, 'call') proxy.RpcProxy.call(self.ctx, msg, topic='other-engine-fake-uuid', timeout=cfg.CONF.engine_life_check_timeout)\ .AndRaise(rpc_common.Timeout) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.man.delete_stack, self.ctx, stack.identifier()) self.assertEqual(ex._exc_info[0], exception.StopActionFailed) self.m.VerifyAll() def test_stack_delete_other_engine_active_lock_succeeded(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() # Insert a fake lock into the db db_api.stack_lock_create(stack.id, "other-engine-fake-uuid") st = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=st).MultipleTimes().AndReturn(stack) self.m.StubOutWithMock(stack_lock.StackLock, 'try_acquire') stack_lock.StackLock.try_acquire().AndReturn("other-engine-fake-uuid") self.m.StubOutWithMock(stack_lock.StackLock, 'engine_alive') stack_lock.StackLock.engine_alive(self.ctx, "other-engine-fake-uuid")\ .AndReturn(True) rpc = proxy.RpcProxy("other-engine-fake-uuid", "1.0") msg = rpc.make_msg("stop_stack", stack_identity=mox.IgnoreArg()) self.m.StubOutWithMock(proxy.RpcProxy, 'call') proxy.RpcProxy.call(self.ctx, msg, topic='other-engine-fake-uuid', timeout=cfg.CONF.engine_life_check_timeout)\ .AndReturn(None) self.m.StubOutWithMock(stack_lock.StackLock, 'acquire') stack_lock.StackLock.acquire().AndReturn(None) self.m.ReplayAll() self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_stack_delete_other_dead_engine_active_lock(self): stack_name = 'service_delete_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() # Insert a fake lock into the db db_api.stack_lock_create(stack.id, "other-engine-fake-uuid") st = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=st).MultipleTimes().AndReturn(stack) self.m.StubOutWithMock(stack_lock.StackLock, 'try_acquire') stack_lock.StackLock.try_acquire().AndReturn("other-engine-fake-uuid") self.m.StubOutWithMock(stack_lock.StackLock, 'engine_alive') stack_lock.StackLock.engine_alive(self.ctx, "other-engine-fake-uuid")\ .AndReturn(False) self.m.StubOutWithMock(stack_lock.StackLock, 'acquire') stack_lock.StackLock.acquire().AndReturn(None) self.m.ReplayAll() self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier())) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_stack_update(self): stack_name = 'service_update_test_stack' params = {'foo': 'bar'} template = '{ "Template": "data" }' old_stack = get_wordpress_stack(stack_name, self.ctx) sid = old_stack.store() s = db_api.stack_get(self.ctx, sid) stack = get_wordpress_stack(stack_name, self.ctx) self.m.StubOutWithMock(parser, 'Stack') self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(self.ctx, stack.name, stack.t, stack.env, timeout_mins=60).AndReturn(stack) self.m.StubOutWithMock(stack, 'validate') stack.validate().AndReturn(None) self.m.StubOutWithMock(threadgroup, 'ThreadGroup') threadgroup.ThreadGroup().AndReturn(DummyThreadGroup()) self.m.ReplayAll() api_args = {'timeout_mins': 60} result = self.man.update_stack(self.ctx, old_stack.identifier(), template, params, None, api_args) self.assertEqual(old_stack.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) self.m.VerifyAll() def test_stack_update_equals(self): stack_name = 'test_stack_update_equals_resource_limit' params = {} res._register_class('GenericResourceType', generic_rsrc.GenericResource) tpl = {'Resources': { 'A': {'Type': 'GenericResourceType'}, 'B': {'Type': 'GenericResourceType'}, 'C': {'Type': 'GenericResourceType'}}} template = parser.Template(tpl) old_stack = parser.Stack(self.ctx, stack_name, template) sid = old_stack.store() s = db_api.stack_get(self.ctx, sid) stack = parser.Stack(self.ctx, stack_name, template) self.m.StubOutWithMock(parser, 'Stack') self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(self.ctx, stack.name, stack.t, stack.env, timeout_mins=60).AndReturn(stack) self.m.StubOutWithMock(stack, 'validate') stack.validate().AndReturn(None) self.m.StubOutWithMock(threadgroup, 'ThreadGroup') threadgroup.ThreadGroup().AndReturn(DummyThreadGroup()) self.m.ReplayAll() cfg.CONF.set_override('max_resources_per_stack', 3) api_args = {'timeout_mins': 60} result = self.man.update_stack(self.ctx, old_stack.identifier(), template, params, None, api_args) self.assertEqual(old_stack.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) self.assertEqual(3, old_stack.root_stack.total_resources()) self.m.VerifyAll() def test_stack_update_stack_id_equal(self): stack_name = 'test_stack_update_stack_id_equal' res._register_class('ResourceWithPropsType', generic_rsrc.ResourceWithProps) tpl = { 'HeatTemplateFormatVersion': '2012-12-12', 'Resources': { 'A': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AWS::StackId'} } } } } template = parser.Template(tpl) create_stack = parser.Stack(self.ctx, stack_name, template) sid = create_stack.store() create_stack.create() self.assertEqual((create_stack.CREATE, create_stack.COMPLETE), create_stack.state) s = db_api.stack_get(self.ctx, sid) old_stack = parser.Stack.load(self.ctx, stack=s) self.assertEqual((old_stack.CREATE, old_stack.COMPLETE), old_stack.state) self.assertEqual(create_stack.identifier().arn(), old_stack['A'].properties['Foo']) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) self.m.ReplayAll() result = self.man.update_stack(self.ctx, create_stack.identifier(), tpl, {}, None, {}) self.man.thread_group_mgr.groups[sid].wait() self.assertEqual((old_stack.UPDATE, old_stack.COMPLETE), old_stack.state) self.assertEqual(create_stack.identifier(), result) self.assertIsNotNone(create_stack.identifier().stack_id) self.assertEqual(create_stack.identifier().arn(), old_stack['A'].properties['Foo']) self.assertEqual(create_stack['A'].id, old_stack['A'].id) self.man.thread_group_mgr.groups[sid].wait() self.m.VerifyAll() def test_nested_stack_update_stack_id_equal(self): stack_name = 'test_stack_update_stack_id_equal' res._register_class('ResourceWithPropsType', generic_rsrc.ResourceWithProps) tpl = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'some_param': {'Type': 'String'} }, 'Resources': { 'nested': { 'Type': 'AWS::CloudFormation::Stack', 'Properties': { 'TemplateURL': 'https://server.test/nested_tpl', 'Parameters': {'some_param': {'Ref': 'some_param'}} } } } } nested_tpl = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'some_param': {'Type': 'String'} }, 'Resources': { 'A': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AWS::StackId'} } } } } self.m.StubOutWithMock(urlfetch, 'get') urlfetch.get('https://server.test/nested_tpl').MultipleTimes().\ AndReturn(json.dumps(nested_tpl)) mox.Replay(urlfetch.get) template = parser.Template(tpl) create_env = environment.Environment({'some_param': 'foo'}) create_stack = parser.Stack(self.ctx, stack_name, template, create_env) sid = create_stack.store() create_stack.create() self.assertEqual((create_stack.CREATE, create_stack.COMPLETE), create_stack.state) s = db_api.stack_get(self.ctx, sid) old_stack = parser.Stack.load(self.ctx, stack=s) self.assertEqual((old_stack.CREATE, old_stack.COMPLETE), old_stack.state) old_nested = old_stack['nested'].nested() self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) self.m.ReplayAll() result = self.man.update_stack(self.ctx, create_stack.identifier(), tpl, {'some_param': 'bar'}, None, {}) self.man.thread_group_mgr.groups[sid].wait() create_nested = create_stack['nested'].nested() self.assertEqual((old_nested.UPDATE, old_nested.COMPLETE), old_nested.state) self.assertEqual(create_stack.identifier(), result) self.assertIsNotNone(create_stack.identifier().stack_id) self.assertEqual(create_nested.identifier().arn(), old_nested['A'].properties['Foo']) self.assertEqual(create_nested['A'].id, old_nested['A'].id) self.m.VerifyAll() def test_stack_update_exceeds_resource_limit(self): stack_name = 'test_stack_update_exceeds_resource_limit' params = {} res._register_class('GenericResourceType', generic_rsrc.GenericResource) tpl = {'Resources': { 'A': {'Type': 'GenericResourceType'}, 'B': {'Type': 'GenericResourceType'}, 'C': {'Type': 'GenericResourceType'}}} template = parser.Template(tpl) old_stack = parser.Stack(self.ctx, stack_name, template) sid = old_stack.store() self.assertIsNotNone(sid) cfg.CONF.set_override('max_resources_per_stack', 2) ex = self.assertRaises(rpc_common.ClientException, self.man.update_stack, self.ctx, old_stack.identifier(), template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.RequestLimitExceeded) self.assertIn(exception.StackResourceLimitExceeded.msg_fmt, str(ex._exc_info[1])) def test_stack_update_verify_err(self): stack_name = 'service_update_verify_err_test_stack' params = {'foo': 'bar'} template = '{ "Template": "data" }' old_stack = get_wordpress_stack(stack_name, self.ctx) old_stack.store() sid = old_stack.store() s = db_api.stack_get(self.ctx, sid) stack = get_wordpress_stack(stack_name, self.ctx) self.m.StubOutWithMock(parser, 'Stack') self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') parser.Template(template, files=None).AndReturn(stack.t) environment.Environment(params).AndReturn(stack.env) parser.Stack(self.ctx, stack.name, stack.t, stack.env, timeout_mins=60).AndReturn(stack) self.m.StubOutWithMock(stack, 'validate') stack.validate().AndRaise(exception.StackValidationFailed( message='fubar')) self.m.ReplayAll() api_args = {'timeout_mins': 60} ex = self.assertRaises( rpc_common.ClientException, self.man.update_stack, self.ctx, old_stack.identifier(), template, params, None, api_args) self.assertEqual(ex._exc_info[0], exception.StackValidationFailed) self.m.VerifyAll() def test_stack_update_nonexist(self): stack_name = 'service_update_nonexist_test_stack' params = {'foo': 'bar'} template = '{ "Template": "data" }' stack = get_wordpress_stack(stack_name, self.ctx) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.man.update_stack, self.ctx, stack.identifier(), template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() def test_stack_update_no_credentials(self): stack_name = 'test_stack_update_no_credentials' params = {'foo': 'bar'} template = '{ "Template": "data" }' old_stack = get_wordpress_stack(stack_name, self.ctx) # force check for credentials on create old_stack['WebServer'].requires_deferred_auth = True sid = old_stack.store() s = db_api.stack_get(self.ctx, sid) self.ctx = utils.dummy_context(password=None) self.m.StubOutWithMock(parser, 'Stack') self.m.StubOutWithMock(parser.Stack, 'load') self.m.StubOutWithMock(parser, 'Template') self.m.StubOutWithMock(environment, 'Environment') self.m.StubOutWithMock(self.man, '_get_stack') self.man._get_stack(self.ctx, old_stack.identifier()).AndReturn(s) parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) parser.Template(template, files=None).AndReturn(old_stack.t) environment.Environment(params).AndReturn(old_stack.env) parser.Stack(self.ctx, old_stack.name, old_stack.t, old_stack.env, timeout_mins=60).AndReturn(old_stack) self.m.ReplayAll() api_args = {'timeout_mins': 60} ex = self.assertRaises(rpc_common.ClientException, self.man.update_stack, self.ctx, old_stack.identifier(), template, params, None, api_args) self.assertEqual(ex._exc_info[0], exception.MissingCredentialError) self.assertEqual( 'Missing required credential: X-Auth-Key', str(ex._exc_info[1])) self.m.VerifyAll() def test_validate_deferred_auth_context_trusts(self): stack = get_wordpress_stack('test_deferred_auth', self.ctx) stack['WebServer'].requires_deferred_auth = True ctx = utils.dummy_context(user=None, password=None) cfg.CONF.set_default('deferred_auth_method', 'trusts') # using trusts, no username or password required self.man._validate_deferred_auth_context(ctx, stack) def test_validate_deferred_auth_context_not_required(self): stack = get_wordpress_stack('test_deferred_auth', self.ctx) stack['WebServer'].requires_deferred_auth = False ctx = utils.dummy_context(user=None, password=None) cfg.CONF.set_default('deferred_auth_method', 'password') # stack performs no deferred operations, so no username or # password required self.man._validate_deferred_auth_context(ctx, stack) def test_validate_deferred_auth_context_missing_credentials(self): stack = get_wordpress_stack('test_deferred_auth', self.ctx) stack['WebServer'].requires_deferred_auth = True cfg.CONF.set_default('deferred_auth_method', 'password') # missing username ctx = utils.dummy_context(user=None) ex = self.assertRaises(exception.MissingCredentialError, self.man._validate_deferred_auth_context, ctx, stack) self.assertEqual('Missing required credential: X-Auth-User', str(ex)) # missing password ctx = utils.dummy_context(password=None) ex = self.assertRaises(exception.MissingCredentialError, self.man._validate_deferred_auth_context, ctx, stack) self.assertEqual('Missing required credential: X-Auth-Key', str(ex)) class StackServiceUpdateNotSupportedTest(HeatTestCase): scenarios = [ ('suspend_in_progress', dict(action='SUSPEND', status='IN_PROGRESS')), ('suspend_complete', dict(action='SUSPEND', status='COMPLETE')), ('suspend_failed', dict(action='SUSPEND', status='FAILED')), ('create_in_progress', dict(action='CREATE', status='IN_PROGRESS')), ('delete_in_progress', dict(action='DELETE', status='IN_PROGRESS')), ('update_in_progress', dict(action='UPDATE', status='IN_PROGRESS')), ('rb_in_progress', dict(action='ROLLBACK', status='IN_PROGRESS')), ('resume_in_progress', dict(action='RESUME', status='IN_PROGRESS')), ] def setUp(self): super(StackServiceUpdateNotSupportedTest, self).setUp() utils.setup_dummy_db() utils.reset_dummy_db() self.ctx = utils.dummy_context() self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.man = service.EngineService('a-host', 'a-topic') def test_stack_update_during(self): stack_name = '%s-%s' % (self.action, self.status) old_stack = get_wordpress_stack(stack_name, self.ctx) old_stack.action = self.action old_stack.status = self.status sid = old_stack.store() s = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser, 'Stack') self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(old_stack) self.m.ReplayAll() params = {'foo': 'bar'} template = '{ "Resources": {} }' ex = self.assertRaises(rpc_common.ClientException, self.man.update_stack, self.ctx, old_stack.identifier(), template, params, None, {}) self.assertEqual(ex._exc_info[0], exception.NotSupported) self.m.VerifyAll() class StackServiceSuspendResumeTest(HeatTestCase): def setUp(self): super(StackServiceSuspendResumeTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.man = service.EngineService('a-host', 'a-topic') def test_stack_suspend(self): stack_name = 'service_suspend_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) sid = stack.store() s = db_api.stack_get(self.ctx, sid) self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=s).AndReturn(stack) thread = self.m.CreateMockAnything() thread.link(mox.IgnoreArg(), stack.id).AndReturn(None) self.m.StubOutWithMock(service.ThreadGroupManager, 'start') service.ThreadGroupManager.start(sid, mox.IgnoreArg(), stack).AndReturn(thread) self.m.ReplayAll() result = self.man.stack_suspend(self.ctx, stack.identifier()) self.assertIsNone(result) self.m.VerifyAll() @stack_context('service_resume_test_stack', False) def test_stack_resume(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) thread = self.m.CreateMockAnything() thread.link(mox.IgnoreArg(), self.stack.id).AndReturn(None) self.m.StubOutWithMock(service.ThreadGroupManager, 'start') service.ThreadGroupManager.start(self.stack.id, mox.IgnoreArg(), self.stack).AndReturn(thread) self.m.ReplayAll() result = self.man.stack_resume(self.ctx, self.stack.identifier()) self.assertIsNone(result) self.m.VerifyAll() def test_stack_suspend_nonexist(self): stack_name = 'service_suspend_nonexist_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.man.stack_suspend, self.ctx, stack.identifier()) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() def test_stack_resume_nonexist(self): stack_name = 'service_resume_nonexist_test_stack' stack = get_wordpress_stack(stack_name, self.ctx) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.man.stack_resume, self.ctx, stack.identifier()) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() class StackServiceAuthorizeTest(HeatTestCase): def setUp(self): super(StackServiceAuthorizeTest, self).setUp() self.ctx = utils.dummy_context(tenant_id='stack_service_test_tenant') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.eng = service.EngineService('a-host', 'a-topic') cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role') res._register_class('ResourceWithPropsType', generic_rsrc.ResourceWithProps) utils.setup_dummy_db() @stack_context('service_authorize_stack_user_nocreds_test_stack') def test_stack_authorize_stack_user_nocreds(self): self.assertFalse(self.eng._authorize_stack_user(self.ctx, self.stack, 'foo')) @stack_context('service_authorize_user_attribute_error_test_stack') def test_stack_authorize_stack_user_attribute_error(self): self.m.StubOutWithMock(json, 'loads') json.loads(None).AndRaise(AttributeError) self.m.ReplayAll() self.assertFalse(self.eng._authorize_stack_user(self.ctx, self.stack, 'foo')) self.m.VerifyAll() @stack_context('service_authorize_stack_user_type_error_test_stack') def test_stack_authorize_stack_user_type_error(self): self.m.StubOutWithMock(json, 'loads') json.loads(mox.IgnoreArg()).AndRaise(TypeError) self.m.ReplayAll() self.assertFalse(self.eng._authorize_stack_user(self.ctx, self.stack, 'foo')) self.m.VerifyAll() def test_stack_authorize_stack_user(self): self.ctx = utils.dummy_context() self.ctx.aws_creds = '{"ec2Credentials": {"access": "4567"}}' stack = get_stack('stack_authorize_stack_user', self.ctx, user_policy_template) self.stack = stack fc = setup_mocks(self.m, stack) self.m.StubOutWithMock(fc.client, 'get_servers_9999') get = fc.client.get_servers_9999 get().AndRaise(service.clients.novaclient.exceptions.NotFound(404)) self.m.ReplayAll() stack.store() stack.create() self.assertTrue(self.eng._authorize_stack_user( self.ctx, self.stack, 'WebServer')) self.assertFalse(self.eng._authorize_stack_user( self.ctx, self.stack, 'CfnUser')) self.assertFalse(self.eng._authorize_stack_user( self.ctx, self.stack, 'NoSuchResource')) self.stack.delete() self.m.VerifyAll() def test_stack_authorize_stack_user_user_id(self): self.ctx = utils.dummy_context(user_id=str(uuid.uuid4())) stack = get_stack('stack_authorize_stack_user', self.ctx, server_config_template) self.stack = stack def handler(resource_name): return resource_name == 'WebServer' self.stack.register_access_allowed_handler(self.ctx.user_id, handler) # matching credential_id and resource_name self.assertTrue(self.eng._authorize_stack_user( self.ctx, self.stack, 'WebServer')) # not matching resource_name self.assertFalse(self.eng._authorize_stack_user( self.ctx, self.stack, 'NoSuchResource')) # not matching credential_id self.ctx.user_id = str(uuid.uuid4()) self.assertFalse(self.eng._authorize_stack_user( self.ctx, self.stack, 'WebServer')) class StackServiceTest(HeatTestCase): def setUp(self): super(StackServiceTest, self).setUp() self.ctx = utils.dummy_context(tenant_id='stack_service_test_tenant') self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.eng = service.EngineService('a-host', 'a-topic') cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role') res._register_class('ResourceWithPropsType', generic_rsrc.ResourceWithProps) utils.setup_dummy_db() @mock.patch.object(service.db_api, 'stack_get_all') @mock.patch.object(service.service.Service, 'start') def test_start_gets_all_stacks(self, mock_super_start, mock_stack_get_all): mock_stack_get_all.return_value = [] self.eng.start() mock_stack_get_all.assert_called_once_with(mock.ANY, tenant_safe=False) @mock.patch.object(service.db_api, 'stack_get_all') @mock.patch.object(service.service.Service, 'start') def test_start_watches_all_stacks(self, mock_super_start, mock_get_all): s1 = mock.Mock(id=1) s2 = mock.Mock(id=2) mock_get_all.return_value = [s1, s2] mock_watch = mock.Mock() self.eng.stack_watch.start_watch_task = mock_watch self.eng.start() calls = mock_watch.call_args_list self.assertEqual(2, mock_watch.call_count) self.assertIn(mock.call(1, mock.ANY), calls) self.assertIn(mock.call(2, mock.ANY), calls) @stack_context('service_identify_test_stack', False) def test_stack_identify(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() identity = self.eng.identify_stack(self.ctx, self.stack.name) self.assertEqual(self.stack.identifier(), identity) self.m.VerifyAll() @stack_context('ef0c41a4-644f-447c-ad80-7eecb0becf79', False) def test_stack_identify_by_name_in_uuid(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() identity = self.eng.identify_stack(self.ctx, self.stack.name) self.assertEqual(self.stack.identifier(), identity) self.m.VerifyAll() @stack_context('service_identify_uuid_test_stack', False) def test_stack_identify_uuid(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() identity = self.eng.identify_stack(self.ctx, self.stack.id) self.assertEqual(self.stack.identifier(), identity) self.m.VerifyAll() def test_stack_identify_nonexist(self): ex = self.assertRaises(rpc_common.ClientException, self.eng.identify_stack, self.ctx, 'wibble') self.assertEqual(ex._exc_info[0], exception.StackNotFound) @stack_context('service_create_existing_test_stack', False) def test_stack_create_existing(self): ex = self.assertRaises(rpc_common.ClientException, self.eng.create_stack, self.ctx, self.stack.name, self.stack.t, {}, None, {}) self.assertEqual(ex._exc_info[0], exception.StackExists) @stack_context('service_name_tenants_test_stack', False) def test_stack_by_name_tenants(self): self.assertEqual(self.stack.id, db_api.stack_get_by_name(self.ctx, self.stack.name).id) ctx2 = utils.dummy_context(tenant_id='stack_service_test_tenant2') self.assertIsNone(db_api.stack_get_by_name(ctx2, self.stack.name)) @stack_context('service_event_list_test_stack') def test_stack_event_list(self): self.m.StubOutWithMock(service.EngineService, '_get_stack') s = db_api.stack_get(self.ctx, self.stack.id) service.EngineService._get_stack(self.ctx, self.stack.identifier(), show_deleted=True).AndReturn(s) self.m.ReplayAll() events = self.eng.list_events(self.ctx, self.stack.identifier()) self.assertEqual(2, len(events)) for ev in events: self.assertIn('event_identity', ev) self.assertIsInstance(ev['event_identity'], dict) self.assertTrue(ev['event_identity']['path'].rsplit('/', 1)[1]) self.assertIn('resource_name', ev) self.assertEqual('WebServer', ev['resource_name']) self.assertIn('physical_resource_id', ev) self.assertIn('resource_properties', ev) # Big long user data field.. it mentions 'wordpress' # a few times so this should work. user_data = ev['resource_properties']['UserData'] self.assertIn('wordpress', user_data) self.assertEqual('F17-x86_64-gold', ev['resource_properties']['ImageId']) self.assertEqual('m1.large', ev['resource_properties']['InstanceType']) self.assertEqual('CREATE', ev['resource_action']) self.assertIn(ev['resource_status'], ('IN_PROGRESS', 'COMPLETE')) self.assertIn('resource_status_reason', ev) self.assertEqual('state changed', ev['resource_status_reason']) self.assertIn('resource_type', ev) self.assertEqual('AWS::EC2::Instance', ev['resource_type']) self.assertIn('stack_identity', ev) self.assertIn('stack_name', ev) self.assertEqual(self.stack.name, ev['stack_name']) self.assertIn('event_time', ev) self.m.VerifyAll() @stack_context('event_list_deleted_stack') def test_stack_event_list_deleted_resource(self): res._register_class('GenericResourceType', generic_rsrc.GenericResource) thread = self.m.CreateMockAnything() thread.link(mox.IgnoreArg(), self.stack.id).AndReturn(None) def run(stack_id, func, *args): func(*args) return thread self.eng.thread_group_mgr.start = run new_tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(instances.Instance, 'handle_delete') instances.Instance.handle_delete() self.m.ReplayAll() result = self.eng.update_stack(self.ctx, self.stack.identifier(), new_tmpl, None, None, {}) # The self.stack reference needs to be updated. Since the underlying # stack is updated in update_stack, the original reference is now # pointing to an orphaned stack object. self.stack = parser.Stack.load(self.ctx, stack_id=result['stack_id']) self.assertEqual(self.stack.identifier(), result) self.assertIsInstance(result, dict) self.assertTrue(result['stack_id']) events = self.eng.list_events(self.ctx, self.stack.identifier()) self.assertEqual(6, len(events)) for ev in events: self.assertIn('event_identity', ev) self.assertIsInstance(ev['event_identity'], dict) self.assertTrue(ev['event_identity']['path'].rsplit('/', 1)[1]) self.assertIn('resource_name', ev) self.assertIn('physical_resource_id', ev) self.assertIn('resource_properties', ev) self.assertIn('resource_status_reason', ev) self.assertIn(ev['resource_action'], ('CREATE', 'DELETE')) self.assertIn(ev['resource_status'], ('IN_PROGRESS', 'COMPLETE')) self.assertIn('resource_type', ev) self.assertIn(ev['resource_type'], ('AWS::EC2::Instance', 'GenericResourceType')) self.assertIn('stack_identity', ev) self.assertIn('stack_name', ev) self.assertEqual(self.stack.name, ev['stack_name']) self.assertIn('event_time', ev) self.m.VerifyAll() @stack_context('service_event_list_test_stack') def test_stack_event_list_by_tenant(self): events = self.eng.list_events(self.ctx, None) self.assertEqual(2, len(events)) for ev in events: self.assertIn('event_identity', ev) self.assertIsInstance(ev['event_identity'], dict) self.assertTrue(ev['event_identity']['path'].rsplit('/', 1)[1]) self.assertIn('resource_name', ev) self.assertEqual('WebServer', ev['resource_name']) self.assertIn('physical_resource_id', ev) self.assertIn('resource_properties', ev) # Big long user data field.. it mentions 'wordpress' # a few times so this should work. user_data = ev['resource_properties']['UserData'] self.assertIn('wordpress', user_data) self.assertEqual('F17-x86_64-gold', ev['resource_properties']['ImageId']) self.assertEqual('m1.large', ev['resource_properties']['InstanceType']) self.assertEqual('CREATE', ev['resource_action']) self.assertIn(ev['resource_status'], ('IN_PROGRESS', 'COMPLETE')) self.assertIn('resource_status_reason', ev) self.assertEqual('state changed', ev['resource_status_reason']) self.assertIn('resource_type', ev) self.assertEqual('AWS::EC2::Instance', ev['resource_type']) self.assertIn('stack_identity', ev) self.assertIn('stack_name', ev) self.assertEqual(self.stack.name, ev['stack_name']) self.assertIn('event_time', ev) self.m.VerifyAll() @stack_context('service_list_all_test_stack') def test_stack_list_all(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg(), resolve_data=False)\ .AndReturn(self.stack) self.m.ReplayAll() sl = self.eng.list_stacks(self.ctx) self.assertEqual(1, len(sl)) for s in sl: self.assertIn('creation_time', s) self.assertIn('updated_time', s) self.assertIn('stack_identity', s) self.assertIsNotNone(s['stack_identity']) self.assertIn('stack_name', s) self.assertEqual(self.stack.name, s['stack_name']) self.assertIn('stack_status', s) self.assertIn('stack_status_reason', s) self.assertIn('description', s) self.assertIn('WordPress', s['description']) self.m.VerifyAll() @mock.patch.object(db_api, 'stack_get_all') def test_stack_list_passes_filtering_info(self, mock_stack_get_all): filters = {'foo': 'bar'} self.eng.list_stacks(self.ctx, filters=filters) mock_stack_get_all.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY, mock.ANY, mock.ANY, filters, mock.ANY, ) @mock.patch.object(db_api, 'stack_get_all') def test_stack_list_tenant_safe_defaults_to_true(self, mock_stack_get_all): self.eng.list_stacks(self.ctx) mock_stack_get_all.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY, mock.ANY, mock.ANY, mock.ANY, True, ) @mock.patch.object(db_api, 'stack_get_all') def test_stack_list_passes_tenant_safe_info(self, mock_stack_get_all): self.eng.list_stacks(self.ctx, tenant_safe=False) mock_stack_get_all.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY, mock.ANY, mock.ANY, mock.ANY, False, ) @mock.patch.object(db_api, 'stack_count_all') def test_count_stacks_passes_filter_info(self, mock_stack_count_all): self.eng.count_stacks(self.ctx, filters={'foo': 'bar'}) mock_stack_count_all.assert_called_once_with(mock.ANY, filters={'foo': 'bar'}, tenant_safe=mock.ANY) @mock.patch.object(db_api, 'stack_count_all') def test_count_stacks_tenant_safe_default_true(self, mock_stack_count_all): self.eng.count_stacks(self.ctx) mock_stack_count_all.assert_called_once_with(mock.ANY, filters=mock.ANY, tenant_safe=True) @mock.patch.object(db_api, 'stack_count_all') def test_count_stacks_passes_tenant_safe_info(self, mock_stack_count_all): self.eng.count_stacks(self.ctx, tenant_safe=False) mock_stack_count_all.assert_called_once_with(mock.ANY, filters=mock.ANY, tenant_safe=False) @stack_context('service_abandon_stack') def test_abandon_stack(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) expected_res = { u'WebServer': { 'action': 'CREATE', 'metadata': {}, 'name': u'WebServer', 'resource_data': {}, 'resource_id': 9999, 'status': 'COMPLETE', 'type': u'AWS::EC2::Instance'}} self.m.ReplayAll() ret = self.eng.abandon_stack(self.ctx, self.stack.identifier()) self.assertEqual(6, len(ret)) self.assertEqual('CREATE', ret['action']) self.assertEqual('COMPLETE', ret['status']) self.assertEqual('service_abandon_stack', ret['name']) self.assertIn('id', ret) self.assertEqual(expected_res, ret['resources']) self.assertEqual(self.stack.t.t, ret['template']) self.m.VerifyAll() def test_stack_describe_nonexistent(self): non_exist_identifier = identifier.HeatIdentifier( self.ctx.tenant_id, 'wibble', '18d06e2e-44d3-4bef-9fbf-52480d604b02') stack_not_found_exc = exception.StackNotFound(stack_name='test') self.m.StubOutWithMock(service.EngineService, '_get_stack') service.EngineService._get_stack( self.ctx, non_exist_identifier, show_deleted=True).AndRaise(stack_not_found_exc) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.show_stack, self.ctx, non_exist_identifier) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() def test_stack_describe_bad_tenant(self): non_exist_identifier = identifier.HeatIdentifier( 'wibble', 'wibble', '18d06e2e-44d3-4bef-9fbf-52480d604b02') invalid_tenant_exc = exception.InvalidTenant(target='test', actual='test') self.m.StubOutWithMock(service.EngineService, '_get_stack') service.EngineService._get_stack( self.ctx, non_exist_identifier, show_deleted=True).AndRaise(invalid_tenant_exc) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.show_stack, self.ctx, non_exist_identifier) self.assertEqual(ex._exc_info[0], exception.InvalidTenant) self.m.VerifyAll() @stack_context('service_describe_test_stack', False) def test_stack_describe(self): self.m.StubOutWithMock(service.EngineService, '_get_stack') s = db_api.stack_get(self.ctx, self.stack.id) service.EngineService._get_stack(self.ctx, self.stack.identifier(), show_deleted=True).AndReturn(s) self.m.ReplayAll() sl = self.eng.show_stack(self.ctx, self.stack.identifier()) self.assertEqual(1, len(sl)) s = sl[0] self.assertIn('creation_time', s) self.assertIn('updated_time', s) self.assertIn('stack_identity', s) self.assertIsNotNone(s['stack_identity']) self.assertIn('stack_name', s) self.assertEqual(self.stack.name, s['stack_name']) self.assertIn('stack_status', s) self.assertIn('stack_status_reason', s) self.assertIn('description', s) self.assertIn('WordPress', s['description']) self.assertIn('parameters', s) self.m.VerifyAll() @stack_context('service_describe_all_test_stack', False) def test_stack_describe_all(self): sl = self.eng.show_stack(self.ctx, None) self.assertEqual(1, len(sl)) s = sl[0] self.assertIn('creation_time', s) self.assertIn('updated_time', s) self.assertIn('stack_identity', s) self.assertIsNotNone(s['stack_identity']) self.assertIn('stack_name', s) self.assertEqual(self.stack.name, s['stack_name']) self.assertIn('stack_status', s) self.assertIn('stack_status_reason', s) self.assertIn('description', s) self.assertIn('WordPress', s['description']) self.assertIn('parameters', s) def test_list_resource_types(self): resources = self.eng.list_resource_types(self.ctx) self.assertIsInstance(resources, list) self.assertIn('AWS::EC2::Instance', resources) self.assertIn('AWS::RDS::DBInstance', resources) def test_list_resource_types_deprecated(self): resources = self.eng.list_resource_types(self.ctx, "DEPRECATED") self.assertEqual(['OS::Neutron::RouterGateway'], resources) def test_list_resource_types_supported(self): resources = self.eng.list_resource_types(self.ctx, "SUPPORTED") self.assertNotIn(['OS::Neutron::RouterGateway'], resources) self.assertIn('AWS::EC2::Instance', resources) def test_resource_schema(self): type_name = 'ResourceWithPropsType' expected = { 'resource_type': type_name, 'properties': { 'Foo': { 'type': 'string', 'required': False, 'update_allowed': False, }, }, 'attributes': { 'foo': {'description': 'A generic attribute'}, 'Foo': {'description': 'Another generic attribute'}, }, } schema = self.eng.resource_schema(self.ctx, type_name=type_name) self.assertEqual(expected, schema) def test_resource_schema_nonexist(self): self.assertRaises(exception.ResourceTypeNotFound, self.eng.resource_schema, self.ctx, type_name='Bogus') @stack_context('service_stack_resource_describe__test_stack') def test_stack_resource_describe(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() r = self.eng.describe_stack_resource(self.ctx, self.stack.identifier(), 'WebServer') self.assertIn('resource_identity', r) self.assertIn('description', r) self.assertIn('updated_time', r) self.assertIn('stack_identity', r) self.assertIsNotNone(r['stack_identity']) self.assertIn('stack_name', r) self.assertEqual(self.stack.name, r['stack_name']) self.assertIn('metadata', r) self.assertIn('resource_status', r) self.assertIn('resource_status_reason', r) self.assertIn('resource_type', r) self.assertIn('physical_resource_id', r) self.assertIn('resource_name', r) self.assertEqual('WebServer', r['resource_name']) self.m.VerifyAll() def test_stack_resource_describe_nonexist_stack(self): non_exist_identifier = identifier.HeatIdentifier( self.ctx.tenant_id, 'wibble', '18d06e2e-44d3-4bef-9fbf-52480d604b02') stack_not_found_exc = exception.StackNotFound(stack_name='test') self.m.StubOutWithMock(service.EngineService, '_get_stack') service.EngineService._get_stack( self.ctx, non_exist_identifier).AndRaise(stack_not_found_exc) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.describe_stack_resource, self.ctx, non_exist_identifier, 'WebServer') self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() @stack_context('service_resource_describe_nonexist_test_stack') def test_stack_resource_describe_nonexist_resource(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.describe_stack_resource, self.ctx, self.stack.identifier(), 'foo') self.assertEqual(ex._exc_info[0], exception.ResourceNotFound) self.m.VerifyAll() @stack_context('service_resource_describe_user_deny_test_stack') def test_stack_resource_describe_stack_user_deny(self): self.ctx.roles = [cfg.CONF.heat_stack_user_role] self.m.StubOutWithMock(service.EngineService, '_authorize_stack_user') service.EngineService._authorize_stack_user(self.ctx, mox.IgnoreArg(), 'foo').AndReturn(False) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.describe_stack_resource, self.ctx, self.stack.identifier(), 'foo') self.assertEqual(ex._exc_info[0], exception.Forbidden) self.m.VerifyAll() @stack_context('service_resources_describe_test_stack') def test_stack_resources_describe(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() resources = self.eng.describe_stack_resources(self.ctx, self.stack.identifier(), 'WebServer') self.assertEqual(1, len(resources)) r = resources[0] self.assertIn('resource_identity', r) self.assertIn('description', r) self.assertIn('updated_time', r) self.assertIn('stack_identity', r) self.assertIsNotNone(r['stack_identity']) self.assertIn('stack_name', r) self.assertEqual(self.stack.name, r['stack_name']) self.assertIn('resource_status', r) self.assertIn('resource_status_reason', r) self.assertIn('resource_type', r) self.assertIn('physical_resource_id', r) self.assertIn('resource_name', r) self.assertEqual('WebServer', r['resource_name']) self.m.VerifyAll() @stack_context('service_resources_describe_no_filter_test_stack') def test_stack_resources_describe_no_filter(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() resources = self.eng.describe_stack_resources(self.ctx, self.stack.identifier(), None) self.assertEqual(1, len(resources)) r = resources[0] self.assertIn('resource_name', r) self.assertEqual('WebServer', r['resource_name']) self.m.VerifyAll() def test_stack_resources_describe_bad_lookup(self): self.m.StubOutWithMock(service.EngineService, '_get_stack') service.EngineService._get_stack( self.ctx, None).AndRaise(TypeError) self.m.ReplayAll() self.assertRaises(TypeError, self.eng.describe_stack_resources, self.ctx, None, 'WebServer') self.m.VerifyAll() def test_stack_resources_describe_nonexist_stack(self): non_exist_identifier = identifier.HeatIdentifier( self.ctx.tenant_id, 'wibble', '18d06e2e-44d3-4bef-9fbf-52480d604b02') ex = self.assertRaises(rpc_common.ClientException, self.eng.describe_stack_resources, self.ctx, non_exist_identifier, 'WebServer') self.assertEqual(ex._exc_info[0], exception.StackNotFound) @stack_context('find_phys_res_stack') def test_find_physical_resource(self): resources = self.eng.describe_stack_resources(self.ctx, self.stack.identifier(), None) phys_id = resources[0]['physical_resource_id'] result = self.eng.find_physical_resource(self.ctx, phys_id) self.assertIsInstance(result, dict) resource_identity = identifier.ResourceIdentifier(**result) self.assertEqual(self.stack.identifier(), resource_identity.stack()) self.assertEqual('WebServer', resource_identity.resource_name) def test_find_physical_resource_nonexist(self): ex = self.assertRaises(rpc_common.ClientException, self.eng.find_physical_resource, self.ctx, 'foo') self.assertEqual(ex._exc_info[0], exception.PhysicalResourceNotFound) @stack_context('service_resources_list_test_stack') def test_stack_resources_list(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() resources = self.eng.list_stack_resources(self.ctx, self.stack.identifier()) self.assertEqual(1, len(resources)) r = resources[0] self.assertIn('resource_identity', r) self.assertIn('updated_time', r) self.assertIn('physical_resource_id', r) self.assertIn('resource_name', r) self.assertEqual('WebServer', r['resource_name']) self.assertIn('resource_status', r) self.assertIn('resource_status_reason', r) self.assertIn('resource_type', r) self.m.VerifyAll() def test_stack_resources_list_nonexist_stack(self): non_exist_identifier = identifier.HeatIdentifier( self.ctx.tenant_id, 'wibble', '18d06e2e-44d3-4bef-9fbf-52480d604b02') stack_not_found_exc = exception.StackNotFound(stack_name='test') self.m.StubOutWithMock(service.EngineService, '_get_stack') service.EngineService._get_stack( self.ctx, non_exist_identifier).AndRaise(stack_not_found_exc) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.list_stack_resources, self.ctx, non_exist_identifier) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() def test_signal_reception(self): stack = get_stack('signal_reception', self.ctx, policy_template) self.stack = stack setup_keystone_mocks(self.m, stack) self.m.ReplayAll() stack.store() stack.create() test_data = {'food': 'yum'} self.m.StubOutWithMock(service.EngineService, '_get_stack') s = db_api.stack_get(self.ctx, self.stack.id) service.EngineService._get_stack(self.ctx, self.stack.identifier()).AndReturn(s) self.m.StubOutWithMock(service.EngineService, 'load_user_creds') service.EngineService.load_user_creds( mox.IgnoreArg()).AndReturn(self.ctx) self.m.StubOutWithMock(res.Resource, 'signal') res.Resource.signal(mox.IgnoreArg()).AndReturn(None) self.m.ReplayAll() self.eng.resource_signal(self.ctx, dict(self.stack.identifier()), 'WebServerScaleDownPolicy', test_data) self.m.VerifyAll() self.stack.delete() def test_signal_reception_no_resource(self): stack = get_stack('signal_reception_no_resource', self.ctx, policy_template) setup_keystone_mocks(self.m, stack) self.stack = stack self.m.ReplayAll() stack.store() stack.create() test_data = {'food': 'yum'} self.m.StubOutWithMock(service.EngineService, '_get_stack') s = db_api.stack_get(self.ctx, self.stack.id) service.EngineService._get_stack(self.ctx, self.stack.identifier()).AndReturn(s) self.m.StubOutWithMock(service.EngineService, 'load_user_creds') service.EngineService.load_user_creds( mox.IgnoreArg()).AndReturn(self.ctx) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.resource_signal, self.ctx, dict(self.stack.identifier()), 'resource_does_not_exist', test_data) self.assertEqual(ex._exc_info[0], exception.ResourceNotFound) self.m.VerifyAll() self.stack.delete() @stack_context('service_metadata_test_stack') def test_metadata(self): test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'} pre_update_meta = self.stack['WebServer'].metadata self.m.StubOutWithMock(service.EngineService, '_get_stack') s = db_api.stack_get(self.ctx, self.stack.id) service.EngineService._get_stack(self.ctx, self.stack.identifier()).AndReturn(s) self.m.StubOutWithMock(instances.Instance, 'metadata_update') instances.Instance.metadata_update(new_metadata=test_metadata) self.m.StubOutWithMock(service.EngineService, 'load_user_creds') service.EngineService.load_user_creds( mox.IgnoreArg()).AndReturn(self.ctx) self.m.ReplayAll() result = self.eng.metadata_update(self.ctx, dict(self.stack.identifier()), 'WebServer', test_metadata) # metadata_update is a no-op for all resources except # WaitConditionHandle so we don't expect this to have changed self.assertEqual(pre_update_meta, result) self.m.VerifyAll() def test_metadata_err_stack(self): non_exist_identifier = identifier.HeatIdentifier( self.ctx.tenant_id, 'wibble', '18d06e2e-44d3-4bef-9fbf-52480d604b02') stack_not_found_exc = exception.StackNotFound(stack_name='test') self.m.StubOutWithMock(service.EngineService, '_get_stack') service.EngineService._get_stack( self.ctx, non_exist_identifier).AndRaise(stack_not_found_exc) self.m.ReplayAll() test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'} ex = self.assertRaises(rpc_common.ClientException, self.eng.metadata_update, self.ctx, non_exist_identifier, 'WebServer', test_metadata) self.assertEqual(ex._exc_info[0], exception.StackNotFound) self.m.VerifyAll() @stack_context('service_metadata_err_resource_test_stack', False) def test_metadata_err_resource(self): self.m.StubOutWithMock(parser.Stack, 'load') parser.Stack.load(self.ctx, stack=mox.IgnoreArg()).AndReturn(self.stack) self.m.ReplayAll() test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'} ex = self.assertRaises(rpc_common.ClientException, self.eng.metadata_update, self.ctx, dict(self.stack.identifier()), 'NooServer', test_metadata) self.assertEqual(ex._exc_info[0], exception.ResourceNotFound) self.m.VerifyAll() @stack_context('periodic_watch_task_not_created') def test_periodic_watch_task_not_created(self): self.eng.thread_group_mgr.groups[self.stack.id] = DummyThreadGroup() self.eng.stack_watch.start_watch_task(self.stack.id, self.ctx) self.assertEqual( [], self.eng.thread_group_mgr.groups[self.stack.id].threads) def test_periodic_watch_task_created(self): stack = get_stack('period_watch_task_created', utils.dummy_context(), alarm_template) self.stack = stack self.m.ReplayAll() stack.store() stack.create() self.eng.thread_group_mgr.groups[stack.id] = DummyThreadGroup() self.eng.stack_watch.start_watch_task(stack.id, self.ctx) expected = [self.eng.stack_watch.periodic_watcher_task] observed = self.eng.thread_group_mgr.groups[stack.id].threads self.assertEqual(expected, observed) self.stack.delete() def test_periodic_watch_task_created_nested(self): self.m.StubOutWithMock(urlfetch, 'get') urlfetch.get('https://server.test/alarm.template').MultipleTimes().\ AndReturn(alarm_template) self.m.ReplayAll() stack = get_stack('period_watch_task_created_nested', utils.dummy_context(), nested_alarm_template) setup_keystone_mocks(self.m, stack) self.stack = stack self.m.ReplayAll() stack.store() stack.create() self.eng.thread_group_mgr.groups[stack.id] = DummyThreadGroup() self.eng.stack_watch.start_watch_task(stack.id, self.ctx) self.assertEqual([self.eng.stack_watch.periodic_watcher_task], self.eng.thread_group_mgr.groups[stack.id].threads) self.stack.delete() @stack_context('service_show_watch_test_stack', False) @utils.wr_delete_after def test_show_watch(self): # Insert two dummy watch rules into the DB rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} self.wr = [] self.wr.append(watchrule.WatchRule(context=self.ctx, watch_name='show_watch_1', rule=rule, watch_data=[], stack_id=self.stack.id, state='NORMAL')) self.wr[0].store() self.wr.append(watchrule.WatchRule(context=self.ctx, watch_name='show_watch_2', rule=rule, watch_data=[], stack_id=self.stack.id, state='NORMAL')) self.wr[1].store() # watch_name=None should return all watches result = self.eng.show_watch(self.ctx, watch_name=None) result_names = [r.get('name') for r in result] self.assertIn('show_watch_1', result_names) self.assertIn('show_watch_2', result_names) result = self.eng.show_watch(self.ctx, watch_name="show_watch_1") self.assertEqual(1, len(result)) self.assertIn('name', result[0]) self.assertEqual('show_watch_1', result[0]['name']) result = self.eng.show_watch(self.ctx, watch_name="show_watch_2") self.assertEqual(1, len(result)) self.assertIn('name', result[0]) self.assertEqual('show_watch_2', result[0]['name']) ex = self.assertRaises(rpc_common.ClientException, self.eng.show_watch, self.ctx, watch_name="nonexistent") self.assertEqual(ex._exc_info[0], exception.WatchRuleNotFound) # Check the response has all keys defined in the engine API for key in engine_api.WATCH_KEYS: self.assertIn(key, result[0]) @stack_context('service_show_watch_metric_test_stack', False) @utils.wr_delete_after def test_show_watch_metric(self): # Insert dummy watch rule into the DB rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='show_watch_metric_1', rule=rule, watch_data=[], stack_id=self.stack.id, state='NORMAL') self.wr.store() # And add a metric datapoint watch = db_api.watch_rule_get_by_name(self.ctx, 'show_watch_metric_1') self.assertIsNotNone(watch) values = {'watch_rule_id': watch.id, 'data': {u'Namespace': u'system/linux', u'ServiceFailure': { u'Units': u'Counter', u'Value': 1}}} watch = db_api.watch_data_create(self.ctx, values) # Check there is one result returned result = self.eng.show_watch_metric(self.ctx, metric_namespace=None, metric_name=None) self.assertEqual(1, len(result)) # Create another metric datapoint and check we get two watch = db_api.watch_data_create(self.ctx, values) result = self.eng.show_watch_metric(self.ctx, metric_namespace=None, metric_name=None) self.assertEqual(2, len(result)) # Check the response has all keys defined in the engine API for key in engine_api.WATCH_DATA_KEYS: self.assertIn(key, result[0]) @stack_context('service_show_watch_state_test_stack') @utils.wr_delete_after def test_set_watch_state(self): # Insert dummy watch rule into the DB rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='OverrideAlarm', rule=rule, watch_data=[], stack_id=self.stack.id, state='NORMAL') self.wr.store() class DummyAction(object): signal = "dummyfoo" dummy_action = DummyAction() self.m.StubOutWithMock(parser.Stack, 'resource_by_refid') parser.Stack.resource_by_refid( 'WebServerRestartPolicy').AndReturn(dummy_action) # Replace the real stack threadgroup with a dummy one, so we can # check the function returned on ALARM is correctly scheduled self.eng.thread_group_mgr.groups[self.stack.id] = DummyThreadGroup() self.m.ReplayAll() state = watchrule.WatchRule.NODATA result = self.eng.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state) self.assertEqual(state, result[engine_api.WATCH_STATE_VALUE]) self.assertEqual( [], self.eng.thread_group_mgr.groups[self.stack.id].threads) state = watchrule.WatchRule.NORMAL result = self.eng.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state) self.assertEqual(state, result[engine_api.WATCH_STATE_VALUE]) self.assertEqual( [], self.eng.thread_group_mgr.groups[self.stack.id].threads) state = watchrule.WatchRule.ALARM result = self.eng.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state) self.assertEqual(state, result[engine_api.WATCH_STATE_VALUE]) self.assertEqual( [DummyAction.signal], self.eng.thread_group_mgr.groups[self.stack.id].threads) self.m.VerifyAll() @stack_context('service_show_watch_state_badstate_test_stack') @utils.wr_delete_after def test_set_watch_state_badstate(self): # Insert dummy watch rule into the DB rule = {u'EvaluationPeriods': u'1', u'AlarmActions': [u'WebServerRestartPolicy'], u'AlarmDescription': u'Restart the WikiDatabase', u'Namespace': u'system/linux', u'Period': u'300', u'ComparisonOperator': u'GreaterThanThreshold', u'Statistic': u'SampleCount', u'Threshold': u'2', u'MetricName': u'ServiceFailure'} self.wr = watchrule.WatchRule(context=self.ctx, watch_name='OverrideAlarm2', rule=rule, watch_data=[], stack_id=self.stack.id, state='NORMAL') self.wr.store() self.m.StubOutWithMock(watchrule.WatchRule, 'set_watch_state') for state in ["HGJHGJHG", "1234", "!\*(&%"]: watchrule.WatchRule.set_watch_state(state)\ .InAnyOrder().AndRaise(ValueError) self.m.ReplayAll() for state in ["HGJHGJHG", "1234", "!\*(&%"]: self.assertRaises(ValueError, self.eng.set_watch_state, self.ctx, watch_name="OverrideAlarm2", state=state) self.m.VerifyAll() def test_set_watch_state_noexist(self): state = watchrule.WatchRule.ALARM # State valid self.m.StubOutWithMock(watchrule.WatchRule, 'load') watchrule.WatchRule.load(self.ctx, "nonexistent")\ .AndRaise(exception.WatchRuleNotFound(watch_name='test')) self.m.ReplayAll() ex = self.assertRaises(rpc_common.ClientException, self.eng.set_watch_state, self.ctx, watch_name="nonexistent", state=state) self.assertEqual(ex._exc_info[0], exception.WatchRuleNotFound) self.m.VerifyAll() def test_stack_list_all_empty(self): sl = self.eng.list_stacks(self.ctx) self.assertEqual(0, len(sl)) def test_stack_describe_all_empty(self): sl = self.eng.show_stack(self.ctx, None) self.assertEqual(0, len(sl)) def test_lazy_load_resources(self): stack_name = 'lazy_load_test' res._register_class('GenericResourceType', generic_rsrc.GenericResource) lazy_load_template = { 'Resources': { 'foo': {'Type': 'GenericResourceType'}, 'bar': { 'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'foo'}, } } } } templ = parser.Template(lazy_load_template) stack = parser.Stack(self.ctx, stack_name, templ, environment.Environment({})) self.assertIsNone(stack._resources) self.assertIsNone(stack._dependencies) resources = stack.resources self.assertIsInstance(resources, dict) self.assertEqual(2, len(resources)) self.assertIsInstance(resources.get('foo'), generic_rsrc.GenericResource) self.assertIsInstance(resources.get('bar'), generic_rsrc.ResourceWithProps) stack_dependencies = stack.dependencies self.assertIsInstance(stack_dependencies, dependencies.Dependencies) self.assertEqual(2, len(stack_dependencies.graph())) def _preview_stack(self): res._register_class('GenericResource1', generic_rsrc.GenericResource) res._register_class('GenericResource2', generic_rsrc.GenericResource) args = {} params = {} files = None stack_name = 'SampleStack' tpl = { 'Description': 'Lorem ipsum.', 'Resources': { 'SampleResource1': {'Type': 'GenericResource1'}, 'SampleResource2': {'Type': 'GenericResource2'}, } } return self.eng.preview_stack(self.ctx, stack_name, tpl, params, files, args) def test_preview_stack_returns_a_stack(self): stack = self._preview_stack() expected_identity = {'path': '', 'stack_id': 'None', 'stack_name': 'SampleStack', 'tenant': 'stack_service_test_tenant'} self.assertEqual(expected_identity, stack['stack_identity']) self.assertEqual('SampleStack', stack['stack_name']) self.assertEqual('Lorem ipsum.', stack['description']) def test_preview_stack_returns_list_of_resources_in_stack(self): stack = self._preview_stack() self.assertIsInstance(stack['resources'], list) self.assertEqual(2, len(stack['resources'])) resource_types = (r['resource_type'] for r in stack['resources']) self.assertIn('GenericResource1', resource_types) self.assertIn('GenericResource2', resource_types) resource_names = (r['resource_name'] for r in stack['resources']) self.assertIn('SampleResource1', resource_names) self.assertIn('SampleResource2', resource_names) def test_preview_stack_validates_new_stack(self): exc = exception.StackExists(stack_name='Validation Failed') self.eng._validate_new_stack = mock.Mock(side_effect=exc) ex = self.assertRaises(rpc_common.ClientException, self._preview_stack) self.assertEqual(ex._exc_info[0], exception.StackExists) @mock.patch.object(service.api, 'format_stack_preview', new=mock.Mock()) @mock.patch.object(service.parser, 'Stack') def test_preview_stack_checks_stack_validity(self, mock_parser): exc = exception.StackValidationFailed(message='Validation Failed') mock_parsed_stack = mock.Mock() mock_parsed_stack.validate.side_effect = exc mock_parser.return_value = mock_parsed_stack ex = self.assertRaises(rpc_common.ClientException, self._preview_stack) self.assertEqual(ex._exc_info[0], exception.StackValidationFailed) @mock.patch.object(service.db_api, 'stack_get_by_name') def test_validate_new_stack_checks_existing_stack(self, mock_stack_get): mock_stack_get.return_value = 'existing_db_stack' self.assertRaises(exception.StackExists, self.eng._validate_new_stack, self.ctx, 'test_existing_stack', 'parsed_template') @mock.patch.object(service.db_api, 'stack_count_all') def test_validate_new_stack_checks_stack_limit(self, mock_db_count): cfg.CONF.set_override('max_stacks_per_tenant', 99) mock_db_count.return_value = 99 template = service.parser.Template({}) self.assertRaises(exception.RequestLimitExceeded, self.eng._validate_new_stack, self.ctx, 'test_existing_stack', template) def test_validate_new_stack_checks_resource_limit(self): cfg.CONF.set_override('max_resources_per_stack', 5) template = {'Resources': [1, 2, 3, 4, 5, 6]} parsed_template = service.parser.Template(template) self.assertRaises(exception.RequestLimitExceeded, self.eng._validate_new_stack, self.ctx, 'test_existing_stack', parsed_template) class SoftwareConfigServiceTest(HeatTestCase): def setUp(self): super(SoftwareConfigServiceTest, self).setUp() self.ctx = utils.dummy_context() self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.engine = service.EngineService('a-host', 'a-topic') utils.setup_dummy_db() def _create_software_config( self, group='Heat::Shell', name='config_mysql', config=None, inputs=[], outputs=[], options={}): return self.engine.create_software_config( self.ctx, group, name, config, inputs, outputs, options) def test_show_software_config(self): config_id = str(uuid.uuid4()) ex = self.assertRaises(rpc_common.ClientException, self.engine.show_software_config, self.ctx, config_id) self.assertEqual(ex._exc_info[0], exception.NotFound) config = self._create_software_config() config_id = config['id'] self.assertEqual( config, self.engine.show_software_config(self.ctx, config_id)) def test_create_software_config(self): config = self._create_software_config() self.assertIsNotNone(config) config_id = config['id'] config = self._create_software_config() self.assertNotEqual(config_id, config['id']) kwargs = { 'group': 'Heat::Chef', 'name': 'config_heat', 'config': '...', 'inputs': [{'name': 'mode'}], 'outputs': [{'name': 'endpoint'}], 'options': {} } config = self._create_software_config(**kwargs) config_id = config['id'] config = self.engine.show_software_config(self.ctx, config_id) self.assertEqual(kwargs['group'], config['group']) self.assertEqual(kwargs['name'], config['name']) self.assertEqual(kwargs['config'], config['config']) self.assertEqual(kwargs['inputs'], config['inputs']) self.assertEqual(kwargs['outputs'], config['outputs']) self.assertEqual(kwargs['options'], config['options']) def test_delete_software_config(self): config = self._create_software_config() self.assertIsNotNone(config) config_id = config['id'] self.engine.delete_software_config(self.ctx, config_id) ex = self.assertRaises(rpc_common.ClientException, self.engine.show_software_config, self.ctx, config_id) self.assertEqual(ex._exc_info[0], exception.NotFound) def _create_software_deployment(self, config_id=None, input_values={}, action='INIT', status='COMPLETE', status_reason='', config_group=None, server_id=str(uuid.uuid4()), config_name=None, stack_user_project_id=None): if config_id is None: config = self._create_software_config(group=config_group, name=config_name) config_id = config['id'] return self.engine.create_software_deployment( self.ctx, server_id, config_id, input_values, action, status, status_reason, stack_user_project_id) def test_list_software_deployments(self): deployment = self._create_software_deployment() deployment_id = deployment['id'] self.assertIsNotNone(deployment) deployments = self.engine.list_software_deployments( self.ctx, server_id=None) self.assertIsNotNone(deployments) deployment_ids = [x['id'] for x in deployments] self.assertIn(deployment_id, deployment_ids) self.assertIn(deployment, deployments) deployments = self.engine.list_software_deployments( self.ctx, server_id=str(uuid.uuid4())) self.assertEqual([], deployments) def test_metadata_software_deployments(self): server_id = str(uuid.uuid4()) stack_user_project_id = str(uuid.uuid4()) d1 = self._create_software_deployment( config_group='mygroup', server_id=server_id, config_name='02_second', stack_user_project_id=stack_user_project_id) d2 = self._create_software_deployment( config_group='mygroup', server_id=server_id, config_name='01_first', stack_user_project_id=stack_user_project_id) d3 = self._create_software_deployment( config_group='myothergroup', server_id=server_id, config_name='03_third', stack_user_project_id=stack_user_project_id) metadata = self.engine.metadata_software_deployments( self.ctx, server_id=server_id) self.assertEqual(3, len(metadata)) self.assertEqual('mygroup', metadata[1]['group']) self.assertEqual('mygroup', metadata[0]['group']) self.assertEqual('myothergroup', metadata[2]['group']) self.assertEqual(d1['config_id'], metadata[1]['id']) self.assertEqual(d2['config_id'], metadata[0]['id']) self.assertEqual(d3['config_id'], metadata[2]['id']) self.assertEqual('01_first', metadata[0]['name']) self.assertEqual('02_second', metadata[1]['name']) self.assertEqual('03_third', metadata[2]['name']) deployments = self.engine.metadata_software_deployments( self.ctx, server_id=str(uuid.uuid4())) self.assertEqual([], deployments) # assert get results when the context tenant_id matches # the stored stack_user_project_id ctx = utils.dummy_context(tenant_id=stack_user_project_id) metadata = self.engine.metadata_software_deployments( ctx, server_id=server_id) self.assertEqual(3, len(metadata)) # assert get no results when the context tenant_id is unknown ctx = utils.dummy_context(tenant_id=str(uuid.uuid4())) metadata = self.engine.metadata_software_deployments( ctx, server_id=server_id) self.assertEqual(0, len(metadata)) def test_show_software_deployment(self): deployment_id = str(uuid.uuid4()) ex = self.assertRaises(rpc_common.ClientException, self.engine.show_software_deployment, self.ctx, deployment_id) self.assertEqual(ex._exc_info[0], exception.NotFound) deployment = self._create_software_deployment() self.assertIsNotNone(deployment) deployment_id = deployment['id'] self.assertEqual( deployment, self.engine.show_software_deployment(self.ctx, deployment_id)) def test_create_software_deployment(self): kwargs = { 'group': 'Heat::Chef', 'name': 'config_heat', 'config': '...', 'inputs': [{'name': 'mode'}], 'outputs': [{'name': 'endpoint'}], 'options': {} } config = self._create_software_config(**kwargs) config_id = config['id'] kwargs = { 'config_id': config_id, 'input_values': {'mode': 'standalone'}, 'action': 'INIT', 'status': 'COMPLETE', 'status_reason': '' } deployment = self._create_software_deployment(**kwargs) deployment_id = deployment['id'] deployment = self.engine.show_software_deployment( self.ctx, deployment_id) self.assertEqual(deployment_id, deployment['id']) self.assertEqual(kwargs['input_values'], deployment['input_values']) def test_update_software_deployment(self): deployment = self._create_software_deployment() self.assertIsNotNone(deployment) deployment_id = deployment['id'] deployment_action = deployment['action'] self.assertEqual('INIT', deployment_action) config_id = deployment['config_id'] self.assertIsNotNone(config_id) updated = self.engine.update_software_deployment( self.ctx, deployment_id=deployment_id, config_id=config_id, input_values={}, output_values={}, action='DEPLOY', status='WAITING', status_reason='') self.assertIsNotNone(updated) self.assertEqual(config_id, updated['config_id']) self.assertEqual('DEPLOY', updated['action']) self.assertEqual('WAITING', updated['status']) def check_software_deployment_updated(**kwargs): values = { 'config_id': None, 'input_values': {}, 'output_values': {}, 'action': {}, 'status': 'WAITING', 'status_reason': '' } values.update(kwargs) updated = self.engine.update_software_deployment( self.ctx, deployment_id, **values) for key, value in kwargs.iteritems(): self.assertEqual(value, updated[key]) check_software_deployment_updated(config_id=config_id) check_software_deployment_updated(input_values={'foo': 'fooooo'}) check_software_deployment_updated(output_values={'bar': 'baaaaa'}) check_software_deployment_updated(action='DEPLOY') check_software_deployment_updated(status='COMPLETE') check_software_deployment_updated(status_reason='Done!') def test_delete_software_deployment(self): deployment_id = str(uuid.uuid4()) ex = self.assertRaises(rpc_common.ClientException, self.engine.delete_software_deployment, self.ctx, deployment_id) self.assertEqual(ex._exc_info[0], exception.NotFound) deployment = self._create_software_deployment() self.assertIsNotNone(deployment) deployment_id = deployment['id'] deployments = self.engine.list_software_deployments( self.ctx, server_id=None) deployment_ids = [x['id'] for x in deployments] self.assertIn(deployment_id, deployment_ids) self.engine.delete_software_deployment(self.ctx, deployment_id) deployments = self.engine.list_software_deployments( self.ctx, server_id=None) deployment_ids = [x['id'] for x in deployments] self.assertNotIn(deployment_id, deployment_ids) class ThreadGroupManagerTest(HeatTestCase): def setUp(self): super(ThreadGroupManagerTest, self).setUp() self.f = 'function' self.fargs = ('spam', 'ham', 'eggs') self.fkwargs = {'foo': 'bar'} self.cnxt = 'ctxt' self.engine_id = 'engine_id' self.stack = mock.Mock() self.lock_mock = mock.Mock() self.stlock_mock = self.useFixture( mockpatch.Patch('heat.engine.service.stack_lock')).mock self.stlock_mock.StackLock.return_value = self.lock_mock self.tg_mock = mock.Mock() self.thg_mock = self.useFixture( mockpatch.Patch('heat.engine.service.threadgroup')).mock self.thg_mock.ThreadGroup.return_value = self.tg_mock self.cfg_mock = self.useFixture( mockpatch.Patch('heat.engine.service.cfg')).mock def test_tgm_start_with_acquired_lock(self): thm = service.ThreadGroupManager() with self.patchobject(thm, 'start'): thm.start_with_acquired_lock(self.stack, self.lock_mock, self.f, *self.fargs, **self.fkwargs) thm.start.assert_called_with(self.stack.id, self.f, *self.fargs, **self.fkwargs) self.assertEqual(self.stack.id, thm.start().link.call_args[0][1]) self.assertFalse(self.lock_mock.release.called) def test_tgm_start_with_acquired_lock_fail(self): thm = service.ThreadGroupManager() with self.patchobject(thm, 'start'): with mock.patch('heat.engine.service.excutils'): thm.start.side_effect = Exception thm.start_with_acquired_lock(self.stack, self.lock_mock, self.f, *self.fargs, **self.fkwargs) self.lock_mock.release.assert_called_with(self.stack.id) def test_tgm_start_with_lock(self): thm = service.ThreadGroupManager() with self.patchobject(thm, 'start_with_acquired_lock'): thm.start_with_lock(self.cnxt, self.stack, self.engine_id, self.f, *self.fargs, **self.fkwargs) self.stlock_mock.StackLock.assert_called_with(self.cnxt, self.stack, self.engine_id) self.lock_mock.acquire.assert_called_once() thm.start_with_acquired_lock.assert_called_once() calls = thm.start_with_acquired_lock.call_args self.assertEqual((self.stack, self.lock_mock, self.f) + self.fargs, calls[0]) self.assertEqual(self.fkwargs, calls[1]) def test_tgm_start(self): stack_id = 'test' thm = service.ThreadGroupManager() ret = thm.start(stack_id, self.f, *self.fargs, **self.fkwargs) self.assertEqual(self.tg_mock, thm.groups['test']) self.tg_mock.add_thread.assert_called_with(self.f, *self.fargs, **self.fkwargs) self.assertEqual(self.tg_mock.add_thread(), ret) def test_tgm_stop(self): stack_id = 'test' thm = service.ThreadGroupManager() thm.start(stack_id, self.f, *self.fargs, **self.fkwargs) thm.stop(stack_id) self.tg_mock.stop.assert_called_once() self.assertNotIn(stack_id, thm.groups) def test_tgm_add_timer(self): stack_id = 'test' thm = service.ThreadGroupManager() thm.add_timer(stack_id, self.f, *self.fargs, **self.fkwargs) self.assertEqual(thm.groups[stack_id], self.tg_mock) self.tg_mock.add_timer.assert_called_with( self.cfg_mock.CONF.periodic_interval, self.f, *self.fargs, **self.fkwargs) heat-2014.1.5/heat/tests/test_ceilometer_alarm.py0000664000567000056700000003773012540642614023043 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. import copy import json import mox from oslo.config import cfg import testtools from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import parser from heat.engine.properties import schemata from heat.engine import resource from heat.engine.resources.ceilometer import alarm from heat.engine import scheduler from heat.engine import stack_user from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import generic_resource from heat.tests import utils ceilometerclient = try_import('ceilometerclient.v2') alarm_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Alarm Test", "Parameters" : {}, "Resources" : { "MEMAlarmHigh": { "Type": "OS::Ceilometer::Alarm", "Properties": { "description": "Scale-up if MEM > 50% for 1 minute", "meter_name": "MemoryUtilization", "statistic": "avg", "period": "60", "evaluation_periods": "1", "threshold": "50", "alarm_actions": [], "matching_metadata": {}, "comparison_operator": "gt" } }, "signal_handler" : { "Type" : "SignalResourceType" } } } ''' not_string_alarm_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Alarm Test", "Parameters" : {}, "Resources" : { "MEMAlarmHigh": { "Type": "OS::Ceilometer::Alarm", "Properties": { "description": "Scale-up if MEM > 50% for 1 minute", "meter_name": "MemoryUtilization", "statistic": "avg", "period": 60, "evaluation_periods": 1, "threshold": 50, "alarm_actions": [], "matching_metadata": {}, "comparison_operator": "gt" } }, "signal_handler" : { "Type" : "SignalResourceType" } } } ''' combination_alarm_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Combination Alarm Test", "Resources" : { "CombinAlarm": { "Type": "OS::Ceilometer::CombinationAlarm", "Properties": { "description": "Do stuff in combination", "alarm_ids": ["alarm1", "alarm2"], "operator": "and", "alarm_actions": [], } } } } ''' class FakeCeilometerAlarm(object): alarm_id = 'foo' class FakeCeilometerAlarms(object): def create(self, **kwargs): pass def update(self, **kwargs): pass def delete(self, alarm_id): pass class FakeCeilometerClient(object): alarms = FakeCeilometerAlarms() @testtools.skipIf(ceilometerclient is None, 'ceilometerclient unavailable') class CeilometerAlarmTest(HeatTestCase): def setUp(self): super(CeilometerAlarmTest, self).setUp() utils.setup_dummy_db() resource._register_class('SignalResourceType', generic_resource.SignalResource) cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() self.fa = FakeCeilometerClient() # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the stack is properly cleaned up def create_stack(self, template=None): if template is None: template = alarm_template temp = template_format.parse(template) template = parser.Template(temp) ctx = utils.dummy_context() ctx.tenant_id = 'test_tenant' stack = parser.Stack(ctx, utils.random_name(), template, disable_rollback=True) stack.store() self.m.StubOutWithMock(stack_user.StackUser, 'keystone') stack_user.StackUser.keystone().MultipleTimes().AndReturn( self.fc) self.m.StubOutWithMock(alarm.CeilometerAlarm, 'ceilometer') alarm.CeilometerAlarm.ceilometer().MultipleTimes().AndReturn( self.fa) al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties']) al['description'] = mox.IgnoreArg() al['name'] = mox.IgnoreArg() al['alarm_actions'] = mox.IgnoreArg() self.m.StubOutWithMock(self.fa.alarms, 'create') self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm()) return stack @utils.stack_delete_after def test_mem_alarm_high_update_no_replace(self): ''' Make sure that we can change the update-able properties without replacing the Alarm rsrc. ''' #short circuit the alarm's references t = template_format.parse(alarm_template) properties = t['Resources']['MEMAlarmHigh']['Properties'] properties['alarm_actions'] = ['signal_handler'] properties['matching_metadata'] = {'a': 'v'} self.stack = self.create_stack(template=json.dumps(t)) self.m.StubOutWithMock(self.fa.alarms, 'update') schema = schemata(alarm.CeilometerAlarm.properties_schema) al2 = dict((k, mox.IgnoreArg()) for k, s in schema.items() if s.update_allowed) al2['alarm_id'] = mox.IgnoreArg() self.fa.alarms.update(**al2).AndReturn(None) self.m.ReplayAll() self.stack.create() rsrc = self.stack['MEMAlarmHigh'] snippet = copy.deepcopy(rsrc.parsed_template()) snippet['Properties']['comparison_operator'] = 'lt' snippet['Properties']['description'] = 'fruity' snippet['Properties']['evaluation_periods'] = '2' snippet['Properties']['period'] = '90' snippet['Properties']['enabled'] = 'true' snippet['Properties']['repeat_actions'] = True snippet['Properties']['statistic'] = 'max' snippet['Properties']['threshold'] = '39' snippet['Properties']['insufficient_data_actions'] = [] snippet['Properties']['alarm_actions'] = [] snippet['Properties']['ok_actions'] = ['signal_handler'] scheduler.TaskRunner(rsrc.update, snippet)() self.m.VerifyAll() @utils.stack_delete_after def test_mem_alarm_high_update_replace(self): ''' Make sure that the Alarm resource IS replaced when non-update-able properties are changed. ''' t = template_format.parse(alarm_template) properties = t['Resources']['MEMAlarmHigh']['Properties'] properties['alarm_actions'] = ['signal_handler'] properties['matching_metadata'] = {'a': 'v'} self.stack = self.create_stack(template=json.dumps(t)) self.m.ReplayAll() self.stack.create() rsrc = self.stack['MEMAlarmHigh'] snippet = copy.deepcopy(rsrc.parsed_template()) snippet['Properties']['meter_name'] = 'temp' updater = scheduler.TaskRunner(rsrc.update, snippet) self.assertRaises(resource.UpdateReplace, updater) self.m.VerifyAll() @utils.stack_delete_after def test_mem_alarm_suspend_resume(self): """ Make sure that the Alarm resource gets disabled on suspend and reenabled on resume. """ self.stack = self.create_stack() self.m.StubOutWithMock(self.fa.alarms, 'update') al_suspend = {'alarm_id': mox.IgnoreArg(), 'enabled': False} self.fa.alarms.update(**al_suspend).AndReturn(None) al_resume = {'alarm_id': mox.IgnoreArg(), 'enabled': True} self.fa.alarms.update(**al_resume).AndReturn(None) self.m.ReplayAll() self.stack.create() rsrc = self.stack['MEMAlarmHigh'] scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @utils.stack_delete_after def test_mem_alarm_high_correct_int_parameters(self): self.stack = self.create_stack(not_string_alarm_template) self.m.ReplayAll() self.stack.create() rsrc = self.stack['MEMAlarmHigh'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertIsNone(rsrc.validate()) self.assertIsInstance(rsrc.properties['evaluation_periods'], int) self.assertIsInstance(rsrc.properties['period'], int) self.assertIsInstance(rsrc.properties['threshold'], int) self.m.VerifyAll() def test_mem_alarm_high_not_correct_string_parameters(self): snippet = template_format.parse(not_string_alarm_template) for p in ('period', 'evaluation_periods'): snippet['Resources']['MEMAlarmHigh']['Properties'][p] = '60a' stack = utils.parse_stack(snippet) rsrc = alarm.CeilometerAlarm( 'MEMAlarmHigh', snippet['Resources']['MEMAlarmHigh'], stack) error = self.assertRaises(exception.StackValidationFailed, rsrc.validate) self.assertEqual( "Property error : MEMAlarmHigh: %s Value '60a' is not an " "integer" % p, str(error)) def test_mem_alarm_high_not_integer_parameters(self): snippet = template_format.parse(not_string_alarm_template) for p in ('period', 'evaluation_periods'): snippet['Resources']['MEMAlarmHigh']['Properties'][p] = [60] stack = utils.parse_stack(snippet) rsrc = alarm.CeilometerAlarm( 'MEMAlarmHigh', snippet['Resources']['MEMAlarmHigh'], stack) error = self.assertRaises(exception.StackValidationFailed, rsrc.validate) self.assertEqual( "Property error : MEMAlarmHigh: %s int() argument must be " "a string or a number, not 'list'" % p, str(error)) def test_mem_alarm_high_check_not_required_parameters(self): snippet = template_format.parse(not_string_alarm_template) snippet['Resources']['MEMAlarmHigh']['Properties'].pop('meter_name') stack = utils.parse_stack(snippet) rsrc = alarm.CeilometerAlarm( 'MEMAlarmHigh', snippet['Resources']['MEMAlarmHigh'], stack) error = self.assertRaises(exception.StackValidationFailed, rsrc.validate) self.assertEqual( "Property error : MEMAlarmHigh: Property meter_name not assigned", str(error)) for p in ('period', 'evaluation_periods', 'statistic', 'comparison_operator'): snippet = template_format.parse(not_string_alarm_template) snippet['Resources']['MEMAlarmHigh']['Properties'].pop(p) stack = utils.parse_stack(snippet) rsrc = alarm.CeilometerAlarm( 'MEMAlarmHigh', snippet['Resources']['MEMAlarmHigh'], stack) self.assertIsNone(rsrc.validate()) def test_delete_alarm_not_found(self): t = template_format.parse(alarm_template) self.stack = self.create_stack(template=json.dumps(t)) self.m.StubOutWithMock(self.fa.alarms, 'delete') self.fa.alarms.delete('foo').AndRaise( alarm.ceilometerclient_exc.HTTPNotFound()) self.m.ReplayAll() self.stack.create() rsrc = self.stack['MEMAlarmHigh'] scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() @testtools.skipIf(ceilometerclient is None, 'ceilometerclient unavailable') class CombinationAlarmTest(HeatTestCase): def setUp(self): super(CombinationAlarmTest, self).setUp() self.fc = FakeCeilometerClient() self.m.StubOutWithMock(clients.OpenStackClients, 'ceilometer') utils.setup_dummy_db() def create_alarm(self): clients.OpenStackClients.ceilometer().MultipleTimes().AndReturn( self.fc) self.m.StubOutWithMock(self.fc.alarms, 'create') self.fc.alarms.create( alarm_actions=[], description=u'Do stuff in combination', name=mox.IgnoreArg(), type='combination', combination_rule={'alarm_ids': [u'alarm1', u'alarm2'], 'operator': u'and'} ).AndReturn(FakeCeilometerAlarm()) snippet = template_format.parse(combination_alarm_template) stack = utils.parse_stack(snippet) return alarm.CombinationAlarm( 'CombinAlarm', snippet['Resources']['CombinAlarm'], stack) def test_create(self): rsrc = self.create_alarm() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual('foo', rsrc.resource_id) self.m.VerifyAll() def test_invalid_alarm_list(self): snippet = template_format.parse(combination_alarm_template) snippet['Resources']['CombinAlarm']['Properties']['alarm_ids'] = [] stack = utils.parse_stack(snippet) rsrc = alarm.CombinationAlarm( 'CombinAlarm', snippet['Resources']['CombinAlarm'], stack) error = self.assertRaises(exception.StackValidationFailed, rsrc.validate) self.assertEqual( "Property error : CombinAlarm: alarm_ids length (0) is out of " "range (min: 1, max: None)", str(error)) def test_update(self): rsrc = self.create_alarm() self.m.StubOutWithMock(self.fc.alarms, 'update') self.fc.alarms.update( alarm_id='foo', combination_rule={'alarm_ids': [u'alarm1', u'alarm3']}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['alarm_ids'] = ['alarm1', 'alarm3'] scheduler.TaskRunner(rsrc.update, update_template)() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_suspend(self): rsrc = self.create_alarm() self.m.StubOutWithMock(self.fc.alarms, 'update') self.fc.alarms.update(alarm_id='foo', enabled=False) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_resume(self): rsrc = self.create_alarm() self.m.StubOutWithMock(self.fc.alarms, 'update') self.fc.alarms.update(alarm_id='foo', enabled=True) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete(self): rsrc = self.create_alarm() self.m.StubOutWithMock(self.fc.alarms, 'delete') self.fc.alarms.delete('foo') self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_not_found(self): rsrc = self.create_alarm() self.m.StubOutWithMock(self.fc.alarms, 'delete') self.fc.alarms.delete('foo').AndRaise( alarm.ceilometerclient_exc.HTTPNotFound()) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_api_openstack_v1_views_views_common.py0000664000567000056700000000702212540642614026756 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. import mock from heat.api.openstack.v1.views import views_common from heat.openstack.common.py3kcompat import urlutils from heat.tests.common import HeatTestCase class TestViewsCommon(HeatTestCase): def setUp(self): super(TestViewsCommon, self).setUp() self.request = mock.Mock() self.stack1 = { 'id': 'id1', } self.stack2 = { 'id': 'id2', } def setUpGetCollectionLinks(self): self.items = [self.stack1, self.stack2] self.request.params = {'limit': '2'} self.request.path_url = "http://example.com/fake/path" def test_get_collection_links_creates_next(self): self.setUpGetCollectionLinks() links = views_common.get_collection_links(self.request, self.items) expected = 'http://example.com/fake/path?marker=id2&limit=2' next_link = filter(lambda link: link['rel'] == 'next', links).pop() self.assertEqual('next', next_link['rel']) self.assertEqual(expected, next_link['href']) def test_get_collection_links_doesnt_create_next_if_no_limit(self): self.setUpGetCollectionLinks() del self.request.params['limit'] links = views_common.get_collection_links(self.request, self.items) self.assertEqual([], links) def test_get_collection_links_doesnt_create_next_if_page_not_full(self): self.setUpGetCollectionLinks() self.request.params['limit'] = '10' links = views_common.get_collection_links(self.request, self.items) self.assertEqual([], links) def test_get_collection_links_overwrites_url_marker(self): self.setUpGetCollectionLinks() self.request.params = {'limit': '2', 'marker': 'some_marker'} links = views_common.get_collection_links(self.request, self.items) expected = 'http://example.com/fake/path?marker=id2&limit=2' next_link = filter(lambda link: link['rel'] == 'next', links).pop() self.assertEqual(expected, next_link['href']) def test_get_collection_links_does_not_overwrite_other_params(self): self.setUpGetCollectionLinks() self.request.params = {'limit': '2', 'foo': 'bar'} links = views_common.get_collection_links(self.request, self.items) next_link = filter(lambda link: link['rel'] == 'next', links).pop() url = next_link['href'] query_string = urlutils.urlparse(url).query params = {} params.update(urlutils.parse_qsl(query_string)) self.assertEqual('2', params['limit']) self.assertEqual('bar', params['foo']) def test_get_collection_links_handles_invalid_limits(self): self.setUpGetCollectionLinks() self.request.params = {'limit': 'foo'} links = views_common.get_collection_links(self.request, self.items) self.assertEqual([], links) self.request.params = {'limit': None} links = views_common.get_collection_links(self.request, self.items) self.assertEqual([], links) heat-2014.1.5/heat/tests/test_heatclient.py0000664000567000056700000014354412540642614021660 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. import json import uuid from oslo.config import cfg cfg.CONF.import_opt('region_name_for_services', 'heat.common.config') cfg.CONF.import_group('keystone_authtoken', 'keystoneclient.middleware.auth_token') import keystoneclient.exceptions as kc_exception from keystoneclient.v3 import client as kc_v3 from heat.common import exception from heat.common import heat_keystoneclient from heat.tests.common import HeatTestCase from heat.tests import utils class KeystoneClientTest(HeatTestCase): """Test cases for heat.common.heat_keystoneclient.""" def setUp(self): super(KeystoneClientTest, self).setUp() self.mock_admin_client = self.m.CreateMock(kc_v3.Client) self.mock_ks_v3_client = self.m.CreateMock(kc_v3.Client) self.m.StubOutWithMock(kc_v3, "Client") dummy_url = 'http://server.test:5000/v2.0' cfg.CONF.set_override('auth_uri', dummy_url, group='keystone_authtoken') cfg.CONF.set_override('admin_user', 'heat', group='keystone_authtoken') cfg.CONF.set_override('admin_password', 'verybadpass', group='keystone_authtoken') cfg.CONF.set_override('admin_tenant_name', 'service', group='keystone_authtoken') cfg.CONF.set_override('stack_user_domain', 'adomain123') cfg.CONF.set_override('stack_domain_admin', 'adminuser123') cfg.CONF.set_override('stack_domain_admin_password', 'adminsecret') self.addCleanup(self.m.VerifyAll) def _stub_admin_client(self, auth_ok=True): kc_v3.Client( auth_url='http://server.test:5000/v3', cacert=None, cert=None, endpoint='http://server.test:5000/v3', insecure=False, key=None, password='verybadpass', project_name='service', username='heat').AndReturn(self.mock_admin_client) self.mock_admin_client.authenticate().AndReturn(auth_ok) if auth_ok: self.mock_admin_client.auth_ref = self.m.CreateMockAnything() self.mock_admin_client.auth_ref.user_id = '1234' def _stub_domain_admin_client(self, auth_ok=True): kc_v3.Client( auth_url='http://server.test:5000/v3', cacert=None, cert=None, endpoint='http://server.test:5000/v3', insecure=False, key=None, password='adminsecret', user_domain_id='adomain123', username='adminuser123').AndReturn(self.mock_admin_client) self.mock_admin_client.authenticate( domain_id='adomain123').AndReturn(auth_ok) if auth_ok: self.mock_admin_client.auth_ref = self.m.CreateMockAnything() self.mock_admin_client.auth_ref.user_id = '1234' def _stubs_v3(self, method='token', auth_ok=True, trust_scoped=True, user_id='trustor_user_id'): if method == 'token': kc_v3.Client( token='abcd1234', project_id='test_tenant_id', auth_url='http://server.test:5000/v3', endpoint='http://server.test:5000/v3', cacert=None, cert=None, insecure=False, key=None).AndReturn(self.mock_ks_v3_client) elif method == 'password': kc_v3.Client( username='test_username', password='password', project_id='test_tenant_id', auth_url='http://server.test:5000/v3', endpoint='http://server.test:5000/v3', cacert=None, cert=None, insecure=False, key=None).AndReturn(self.mock_ks_v3_client) elif method == 'trust': kc_v3.Client( username='heat', password='verybadpass', auth_url='http://server.test:5000/v3', endpoint='http://server.test:5000/v3', trust_id='atrust123', cacert=None, cert=None, insecure=False, key=None).AndReturn(self.mock_ks_v3_client) self.mock_ks_v3_client.auth_ref = self.m.CreateMockAnything() self.mock_ks_v3_client.auth_ref.user_id = user_id self.mock_ks_v3_client.auth_ref.trust_scoped = trust_scoped self.mock_ks_v3_client.auth_ref.auth_token = 'atrusttoken' self.mock_ks_v3_client.authenticate().AndReturn(auth_ok) def test_username_length(self): """Test that user names >64 characters are properly truncated.""" self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None # a >64 character user name and the expected version long_user_name = 'U' * 64 + 'S' good_user_name = long_user_name[-64:] # mock keystone client user functions self.mock_ks_v3_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = 'auser123' # when keystone is called, the name should have been truncated # to the last 64 characters of the long name self.mock_ks_v3_client.users.create(name=good_user_name, password='password', default_project=ctx.tenant_id ).AndReturn(mock_user) self.mock_ks_v3_client.roles = self.m.CreateMockAnything() self.mock_ks_v3_client.roles.list().AndReturn(self._mock_roles_list()) self.mock_ks_v3_client.roles.grant(project=ctx.tenant_id, role='4546', user='auser123').AndReturn(None) self.m.ReplayAll() # call create_stack_user with a long user name. # the cleanup VerifyAll should verify that though we passed # long_user_name, keystone was actually called with a truncated # user name heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.create_stack_user(long_user_name, password='password') def test_create_stack_user_error_norole(self): """Test error path when no role is found.""" self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None self.mock_ks_v3_client.roles = self.m.CreateMockAnything() mock_roles_list = self._mock_roles_list(heat_stack_user='badrole') self.mock_ks_v3_client.roles.list().AndReturn(mock_roles_list) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) err = self.assertRaises(exception.Error, heat_ks_client.create_stack_user, 'auser', password='password') self.assertIn('Can\'t find role heat_stack_user', str(err)) def _mock_roles_list(self, heat_stack_user='heat_stack_user'): mock_roles_list = [] for r_id, r_name in (('1234', 'blah'), ('4546', heat_stack_user)): mock_role = self.m.CreateMockAnything() mock_role.id = r_id mock_role.name = r_name mock_roles_list.append(mock_role) return mock_roles_list def test_create_stack_domain_user(self): """Test creating a stack domain user.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self.mock_admin_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = 'duser123' self.mock_admin_client.users.create(name='duser', password=None, default_project='aproject', domain='adomain123' ).AndReturn(mock_user) self.mock_admin_client.roles = self.m.CreateMockAnything() self.mock_admin_client.roles.list().AndReturn(self._mock_roles_list()) self.mock_admin_client.roles.grant(project='aproject', role='4546', user='duser123').AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.create_stack_domain_user(username='duser', project_id='aproject') def test_create_stack_domain_user_legacy_fallback(self): """Test creating a stack domain user, fallback path.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stubs_v3() self.mock_ks_v3_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = 'auser123' self.mock_ks_v3_client.users.create(name='auser', password='password', default_project=ctx.tenant_id ).AndReturn(mock_user) self.mock_ks_v3_client.roles = self.m.CreateMockAnything() self.mock_ks_v3_client.roles.list().AndReturn(self._mock_roles_list()) self.mock_ks_v3_client.roles.grant(project=ctx.tenant_id, role='4546', user='auser123').AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.create_stack_domain_user(username='auser', project_id='aproject', password='password') def test_create_stack_domain_user_error_norole(self): """Test creating a stack domain user, no role error path.""" ctx = utils.dummy_context() ctx.trust_id = None self._stub_domain_admin_client() # mock keystone client functions self.mock_admin_client.roles = self.m.CreateMockAnything() mock_roles_list = self._mock_roles_list(heat_stack_user='badrole') self.mock_admin_client.roles.list().AndReturn(mock_roles_list) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) err = self.assertRaises(exception.Error, heat_ks_client.create_stack_domain_user, username='duser', project_id='aproject') self.assertIn('Can\'t find role heat_stack_user', str(err)) def test_delete_stack_domain_user(self): """Test deleting a stack domain user.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self.mock_admin_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = 'duser123' mock_user.domain_id = 'adomain123' mock_user.default_project_id = 'aproject' self.mock_admin_client.users.get('duser123').AndReturn(mock_user) self.mock_admin_client.users.delete('duser123').AndReturn(None) self.mock_admin_client.users.get('duser123').AndRaise( kc_exception.NotFound) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_user(user_id='duser123', project_id='aproject') # Second delete will raise ignored NotFound heat_ks_client.delete_stack_domain_user(user_id='duser123', project_id='aproject') def test_delete_stack_domain_user_legacy_fallback(self): """Test deleting a stack domain user, fallback path.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stubs_v3() self.mock_ks_v3_client.users = self.m.CreateMockAnything() self.mock_ks_v3_client.users.delete(user='user123').AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_user(user_id='user123', project_id='aproject') def test_delete_stack_domain_user_error_domain(self): """Test deleting a stack domain user, wrong domain.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self.mock_admin_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = 'duser123' mock_user.domain_id = 'notadomain123' mock_user.default_project_id = 'aproject' self.mock_admin_client.users.get('duser123').AndReturn(mock_user) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) err = self.assertRaises(ValueError, heat_ks_client.delete_stack_domain_user, user_id='duser123', project_id='aproject') self.assertIn('User delete in invalid domain', err) def test_delete_stack_domain_user_error_project(self): """Test deleting a stack domain user, wrong project.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self.mock_admin_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = 'duser123' mock_user.domain_id = 'adomain123' mock_user.default_project_id = 'notaproject' self.mock_admin_client.users.get('duser123').AndReturn(mock_user) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) err = self.assertRaises(ValueError, heat_ks_client.delete_stack_domain_user, user_id='duser123', project_id='aproject') self.assertIn('User delete in invalid project', err) def test_delete_stack_user(self): """Test deleting a stack user.""" self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client delete function self.mock_ks_v3_client.users = self.m.CreateMockAnything() self.mock_ks_v3_client.users.delete(user='atestuser').AndReturn(None) self.mock_ks_v3_client.users.delete(user='atestuser').AndRaise( kc_exception.NotFound) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_user('atestuser') # Second delete will raise ignored NotFound heat_ks_client.delete_stack_user('atestuser') def test_init_v3_token(self): """Test creating the client, token auth.""" self._stubs_v3() self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.client self.assertIsNotNone(heat_ks_client._client) def test_init_v3_password(self): """Test creating the client, password auth.""" self._stubs_v3(method='password') self.m.ReplayAll() ctx = utils.dummy_context() ctx.auth_token = None ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) client = heat_ks_client.client self.assertIsNotNone(client) def test_init_v3_bad_nocreds(self): """Test creating the client, no credentials.""" ctx = utils.dummy_context() ctx.auth_token = None ctx.trust_id = None ctx.username = None ctx.password = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(exception.AuthorizationFailure, heat_ks_client._v3_client_init) def test_create_trust_context_trust_id(self): """Test create_trust_context with existing trust_id.""" self._stubs_v3(method='trust') cfg.CONF.set_override('deferred_auth_method', 'trusts') self.m.ReplayAll() ctx = utils.dummy_context() ctx.trust_id = 'atrust123' ctx.trustor_user_id = 'trustor_user_id' heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) trust_context = heat_ks_client.create_trust_context() self.assertEqual(ctx.to_dict(), trust_context.to_dict()) def test_create_trust_context_trust_create(self): """Test create_trust_context when creating a trust.""" class MockTrust(object): id = 'atrust123' self._stub_admin_client() self._stubs_v3() cfg.CONF.set_override('deferred_auth_method', 'trusts') cfg.CONF.set_override('trusts_delegated_roles', ['heat_stack_owner']) self.mock_ks_v3_client.auth_ref = self.m.CreateMockAnything() self.mock_ks_v3_client.auth_ref.user_id = '5678' self.mock_ks_v3_client.auth_ref.project_id = '42' self.mock_ks_v3_client.trusts = self.m.CreateMockAnything() self.mock_ks_v3_client.trusts.create( trustor_user='5678', trustee_user='1234', project='42', impersonation=True, role_names=['heat_stack_owner']).AndReturn(MockTrust()) self.m.ReplayAll() ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) trust_context = heat_ks_client.create_trust_context() self.assertEqual('atrust123', trust_context.trust_id) self.assertEqual('5678', trust_context.trustor_user_id) def test_init_domain_cfg_not_set_fallback(self): """Test error path when config lacks domain config.""" cfg.CONF.clear_override('stack_user_domain') cfg.CONF.clear_override('stack_domain_admin') cfg.CONF.clear_override('stack_domain_admin_password') ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.trust_id = None self.assertIsNotNone(heat_keystoneclient.KeystoneClient(ctx)) def test_init_domain_cfg_not_set_error(self): """Test error path when config lacks domain config.""" cfg.CONF.clear_override('stack_domain_admin') cfg.CONF.clear_override('stack_domain_admin_password') ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.trust_id = None err = self.assertRaises(exception.Error, heat_keystoneclient.KeystoneClient, ctx) exp_msg = ('heat.conf misconfigured, cannot specify stack_user_domain ' 'without stack_domain_admin and ' 'stack_domain_admin_password') self.assertIn(exp_msg, str(err)) def test_init_admin_client(self): """Test the admin_client property.""" self._stub_admin_client() self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertEqual(self.mock_admin_client, heat_ks_client.admin_client) self.assertEqual(self.mock_admin_client, heat_ks_client._admin_client) def test_init_admin_client_denied(self): """Test the admin_client property, auth failure path.""" self._stub_admin_client(auth_ok=False) self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) # Define wrapper for property or the property raises the exception # outside of the assertRaises which fails the test def get_admin_client(): heat_ks_client.admin_client self.assertRaises(exception.AuthorizationFailure, get_admin_client) def test_trust_init(self): """Test consuming a trust when initializing.""" self._stubs_v3(method='trust') cfg.CONF.set_override('deferred_auth_method', 'trusts') self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.auth_token = None ctx.trust_id = 'atrust123' ctx.trustor_user_id = 'trustor_user_id' heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNotNone(heat_ks_client.client) def test_trust_init_fail(self): """Test consuming a trust when initializing, error scoping.""" self._stubs_v3(method='trust', trust_scoped=False) cfg.CONF.set_override('deferred_auth_method', 'trusts') self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.auth_token = None ctx.trust_id = 'atrust123' ctx.trustor_user_id = 'trustor_user_id' self.assertRaises(exception.AuthorizationFailure, heat_keystoneclient.KeystoneClient, ctx) def test_trust_init_fail_impersonation(self): """Test consuming a trust when initializing, impersonation error.""" self._stubs_v3(method='trust', user_id='wrong_user_id') cfg.CONF.set_override('deferred_auth_method', 'trusts') self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = 'heat' ctx.password = None ctx.auth_token = None ctx.trust_id = 'atrust123' ctx.trustor_user_id = 'trustor_user_id' self.assertRaises(exception.AuthorizationFailure, heat_keystoneclient.KeystoneClient, ctx) def test_trust_init_pw(self): """Test trust_id is takes precedence username/password specified.""" self._stubs_v3(method='trust') self.m.ReplayAll() ctx = utils.dummy_context() ctx.auth_token = None ctx.trust_id = 'atrust123' ctx.trustor_user_id = 'trustor_user_id' heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNotNone(heat_ks_client._client) def test_trust_init_token(self): """Test trust_id takes precedence when token specified.""" self._stubs_v3(method='trust') self.m.ReplayAll() ctx = utils.dummy_context() ctx.username = None ctx.password = None ctx.trust_id = 'atrust123' ctx.trustor_user_id = 'trustor_user_id' heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNotNone(heat_ks_client._client) def test_delete_trust(self): """Test delete_trust when deleting trust.""" self._stubs_v3() cfg.CONF.set_override('deferred_auth_method', 'trusts') self.mock_ks_v3_client.trusts = self.m.CreateMockAnything() self.mock_ks_v3_client.trusts.delete('atrust123').AndReturn(None) self.m.ReplayAll() ctx = utils.dummy_context() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNone(heat_ks_client.delete_trust(trust_id='atrust123')) def test_delete_trust_not_found(self): """Test delete_trust when trust already deleted.""" self._stubs_v3() cfg.CONF.set_override('deferred_auth_method', 'trusts') self.mock_ks_v3_client.trusts = self.m.CreateMockAnything() self.mock_ks_v3_client.trusts.delete('atrust123').AndRaise( kc_exception.NotFound) self.m.ReplayAll() ctx = utils.dummy_context() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNone(heat_ks_client.delete_trust(trust_id='atrust123')) def test_disable_stack_user(self): """Test disabling a stack user.""" self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client update function self.mock_ks_v3_client.users = self.m.CreateMockAnything() self.mock_ks_v3_client.users.update(user='atestuser', enabled=False ).AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.disable_stack_user('atestuser') def test_enable_stack_user(self): """Test enabling a stack user.""" self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client update function self.mock_ks_v3_client.users = self.m.CreateMockAnything() self.mock_ks_v3_client.users.update(user='atestuser', enabled=True ).AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.enable_stack_user('atestuser') def _stub_admin_user_get(self, user_id, domain_id, project_id): self.mock_admin_client.users = self.m.CreateMockAnything() mock_user = self.m.CreateMockAnything() mock_user.id = user_id mock_user.domain_id = domain_id mock_user.default_project_id = project_id self.mock_admin_client.users.get(user_id).AndReturn(mock_user) return mock_user def test_enable_stack_domain_user(self): """Test enabling a stack domain user.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'adomain123', 'aproject') self.mock_admin_client.users.update(user='duser123', enabled=True ).AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.enable_stack_domain_user(user_id='duser123', project_id='aproject') def test_enable_stack_domain_user_legacy_fallback(self): """Test enabling a stack domain user, fallback path.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stubs_v3() self.mock_ks_v3_client.users = self.m.CreateMockAnything() self.mock_ks_v3_client.users.update(user='user123', enabled=True ).AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.enable_stack_domain_user(user_id='user123', project_id='aproject') def test_enable_stack_domain_user_error_project(self): """Test enabling a stack domain user, wrong project.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'adomain123', 'notaproject') self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.enable_stack_domain_user, user_id='duser123', project_id='aproject') def test_enable_stack_domain_user_error_domain(self): """Test enabling a stack domain user, wrong domain.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'notadomain123', 'aproject') self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.enable_stack_domain_user, user_id='duser123', project_id='aproject') def test_disable_stack_domain_user(self): """Test disabling a stack domain user.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'adomain123', 'aproject') self.mock_admin_client.users.update(user='duser123', enabled=False ).AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.disable_stack_domain_user(user_id='duser123', project_id='aproject') def test_disable_stack_domain_user_legacy_fallback(self): """Test enabling a stack domain user, fallback path.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stubs_v3() self.mock_ks_v3_client.users = self.m.CreateMockAnything() self.mock_ks_v3_client.users.update(user='user123', enabled=False ).AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.disable_stack_domain_user(user_id='user123', project_id='aproject') def test_disable_stack_domain_user_error_project(self): """Test disabling a stack domain user, wrong project.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'adomain123', 'notaproject') self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.disable_stack_domain_user, user_id='duser123', project_id='aproject') def test_disable_stack_domain_user_error_domain(self): """Test disabling a stack domain user, wrong domain.""" ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'notadomain123', 'aproject') self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.disable_stack_domain_user, user_id='duser123', project_id='aproject') def test_delete_stack_domain_user_keypair(self): ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() user = self._stub_admin_user_get('duser123', 'adomain123', 'aproject') self.mock_admin_client.credentials = self.m.CreateMockAnything() self.mock_admin_client.credentials.delete( 'acredentialid').AndReturn(None) self.mock_admin_client.users.get('duser123').AndReturn(user) self.mock_admin_client.credentials.delete( 'acredentialid').AndRaise(kc_exception.NotFound) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_user_keypair( user_id='duser123', project_id='aproject', credential_id='acredentialid') # Second delete will raise ignored NotFound heat_ks_client.delete_stack_domain_user_keypair( user_id='duser123', project_id='aproject', credential_id='acredentialid') def test_delete_stack_domain_user_keypair_legacy_fallback(self): cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stubs_v3() self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() self.mock_ks_v3_client.credentials.delete( 'acredentialid').AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_user_keypair( user_id='user123', project_id='aproject', credential_id='acredentialid') def test_delete_stack_domain_user_keypair_error_project(self): ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'adomain123', 'notaproject') self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.delete_stack_domain_user_keypair, user_id='duser123', project_id='aproject', credential_id='acredentialid') def test_delete_stack_domain_user_keypair_error_domain(self): ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client functions self._stub_domain_admin_client() self._stub_admin_user_get('duser123', 'notadomain123', 'aproject') self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.delete_stack_domain_user_keypair, user_id='duser123', project_id='aproject', credential_id='acredentialid') def _stub_uuid(self, values=[]): # stub UUID.hex to return the values specified self.m.StubOutWithMock(uuid, 'uuid4') for v in values: mock_uuid = self.m.CreateMockAnything() mock_uuid.hex = v uuid.uuid4().AndReturn(mock_uuid) def test_create_ec2_keypair(self): """Test creating ec2 credentials.""" self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None ex_data = {'access': 'dummy_access', 'secret': 'dummy_secret'} ex_data_json = json.dumps(ex_data) # stub UUID.hex to match ex_data self._stub_uuid(['dummy_access', 'dummy_secret']) # mock keystone client credentials functions self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() mock_credential = self.m.CreateMockAnything() mock_credential.id = '123456' mock_credential.user_id = 'atestuser' mock_credential.blob = ex_data_json mock_credential.type = 'ec2' # mock keystone client create function self.mock_ks_v3_client.credentials.create( user='atestuser', type='ec2', data=ex_data_json, project=ctx.tenant_id).AndReturn(mock_credential) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) ec2_cred = heat_ks_client.create_ec2_keypair(user_id='atestuser') self.assertEqual('123456', ec2_cred.id) self.assertEqual('dummy_access', ec2_cred.access) self.assertEqual('dummy_secret', ec2_cred.secret) def test_create_stack_domain_user_keypair(self): """Test creating ec2 credentials for domain user.""" self._stub_domain_admin_client() ctx = utils.dummy_context() ctx.trust_id = None ex_data = {'access': 'dummy_access2', 'secret': 'dummy_secret2'} ex_data_json = json.dumps(ex_data) # stub UUID.hex to match ex_data self._stub_uuid(['dummy_access2', 'dummy_secret2']) # mock keystone client credentials functions self.mock_admin_client.credentials = self.m.CreateMockAnything() mock_credential = self.m.CreateMockAnything() mock_credential.id = '1234567' mock_credential.user_id = 'atestuser2' mock_credential.blob = ex_data_json mock_credential.type = 'ec2' # mock keystone client create function self.mock_admin_client.credentials.create( user='atestuser2', type='ec2', data=ex_data_json, project='aproject').AndReturn(mock_credential) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) ec2_cred = heat_ks_client.create_stack_domain_user_keypair( user_id='atestuser2', project_id='aproject') self.assertEqual('1234567', ec2_cred.id) self.assertEqual('dummy_access2', ec2_cred.access) self.assertEqual('dummy_secret2', ec2_cred.secret) def test_create_stack_domain_user_keypair_legacy_fallback(self): """Test creating ec2 credentials for domain user, fallback path.""" cfg.CONF.clear_override('stack_user_domain') self._stubs_v3() ctx = utils.dummy_context() ctx.trust_id = None ex_data = {'access': 'dummy_access2', 'secret': 'dummy_secret2'} ex_data_json = json.dumps(ex_data) # stub UUID.hex to match ex_data self._stub_uuid(['dummy_access2', 'dummy_secret2']) # mock keystone client credentials functions self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() mock_credential = self.m.CreateMockAnything() mock_credential.id = '1234567' mock_credential.user_id = 'atestuser2' mock_credential.blob = ex_data_json mock_credential.type = 'ec2' # mock keystone client create function self.mock_ks_v3_client.credentials.create( user='atestuser2', type='ec2', data=ex_data_json, project=ctx.tenant_id).AndReturn(mock_credential) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) ec2_cred = heat_ks_client.create_stack_domain_user_keypair( user_id='atestuser2', project_id='aproject') self.assertEqual('1234567', ec2_cred.id) self.assertEqual('dummy_access2', ec2_cred.access) self.assertEqual('dummy_secret2', ec2_cred.secret) def test_get_ec2_keypair_id(self): """Test getting ec2 credential by id.""" user_id = 'atestuser' self._stubs_v3(user_id=user_id) ctx = utils.dummy_context() ctx.trust_id = None ex_data = {'access': 'access123', 'secret': 'secret456'} ex_data_json = json.dumps(ex_data) # Create a mock credential response credential_id = 'acredential123' mock_credential = self.m.CreateMockAnything() mock_credential.id = credential_id mock_credential.user_id = user_id mock_credential.blob = ex_data_json mock_credential.type = 'ec2' # mock keystone client get function self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() self.mock_ks_v3_client.credentials.get( credential_id).AndReturn(mock_credential) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) ec2_cred = heat_ks_client.get_ec2_keypair(credential_id=credential_id) self.assertEqual(credential_id, ec2_cred.id) self.assertEqual('access123', ec2_cred.access) self.assertEqual('secret456', ec2_cred.secret) def _mock_credential_list(self, user_id): """Create a mock credential list response.""" mock_credential_list = [] for x in (1, 2, 3): mock_credential = self.m.CreateMockAnything() mock_credential.id = 'credential_id%s' % x mock_credential.user_id = user_id mock_credential.blob = json.dumps({'access': 'access%s' % x, 'secret': 'secret%s' % x}) mock_credential.type = 'ec2' mock_credential_list.append(mock_credential) # mock keystone client list function self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() self.mock_ks_v3_client.credentials.list().AndReturn( mock_credential_list) def test_get_ec2_keypair_access(self): """Test getting ec2 credential by access.""" user_id = 'atestuser' self._stubs_v3(user_id=user_id) ctx = utils.dummy_context() ctx.trust_id = None self._mock_credential_list(user_id=user_id) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) ec2_cred = heat_ks_client.get_ec2_keypair(access='access2') self.assertEqual('credential_id2', ec2_cred.id) self.assertEqual('access2', ec2_cred.access) self.assertEqual('secret2', ec2_cred.secret) def test_get_ec2_keypair_error(self): """Test getting ec2 credential error path.""" ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.get_ec2_keypair) def test_delete_ec2_keypair_id(self): """Test deleting ec2 credential by id.""" user_id = 'atestuser' self._stubs_v3(user_id=user_id) ctx = utils.dummy_context() ctx.trust_id = None # mock keystone client credentials functions credential_id = 'acredential123' self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() # mock keystone client delete function self.mock_ks_v3_client.credentials = self.m.CreateMockAnything() self.mock_ks_v3_client.credentials.delete(credential_id) self.mock_ks_v3_client.credentials.delete(credential_id).AndRaise( kc_exception.NotFound) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNone(heat_ks_client.delete_ec2_keypair( credential_id=credential_id)) # Second delete will raise ignored NotFound self.assertIsNone(heat_ks_client.delete_ec2_keypair( credential_id=credential_id)) def test_delete_ec2_keypair_access(self): """Test deleting ec2 credential by access.""" user_id = 'atestuser' self._stubs_v3(user_id=user_id) ctx = utils.dummy_context() ctx.trust_id = None self._mock_credential_list(user_id=user_id) # mock keystone client delete function self.mock_ks_v3_client.credentials.delete( 'credential_id2').AndReturn(None) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNone(heat_ks_client.delete_ec2_keypair(access='access2')) def test_deleting_ec2_keypair_error(self): """Test deleting ec2 credential error path.""" ctx = utils.dummy_context() ctx.trust_id = None self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertRaises(ValueError, heat_ks_client.delete_ec2_keypair) def test_create_stack_domain_project(self): """Test the create_stack_domain_project function.""" ctx = utils.dummy_context() ctx.trust_id = None expected_name = '%s-astack' % ctx.tenant_id self._stub_domain_admin_client() self.mock_admin_client.projects = self.m.CreateMockAnything() dummy = self.m.CreateMockAnything() dummy.id = 'aproject123' self.mock_admin_client.projects.create( name=expected_name, domain='adomain123', description='Heat stack user project').AndReturn(dummy) self.m.ReplayAll() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertEqual('aproject123', heat_ks_client.create_stack_domain_project('astack')) def test_create_stack_domain_project_legacy_fallback(self): """Test the create_stack_domain_project function, fallback path.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertEqual(ctx.tenant_id, heat_ks_client.create_stack_domain_project('astack')) def test_delete_stack_domain_project(self): """Test the delete_stack_domain_project function.""" self._stub_domain_admin_client() self.mock_admin_client.projects = self.m.CreateMockAnything() dummy = self.m.CreateMockAnything() dummy.id = 'aproject123' dummy.domain_id = 'adomain123' dummy.delete().AndReturn(None) self.mock_admin_client.projects.get(project='aprojectid').AndReturn( dummy) self.m.ReplayAll() ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_project(project_id='aprojectid') def test_delete_stack_domain_project_notfound(self): """Test the delete_stack_domain_project function.""" self._stub_domain_admin_client() self.mock_admin_client.projects = self.m.CreateMockAnything() dummy = self.m.CreateMockAnything() dummy.id = 'aproject123' dummy.domain_id = 'adomain123' dummy.delete().AndRaise(kc_exception.NotFound) self.mock_admin_client.projects.get(project='aprojectid').AndReturn( dummy) self.m.ReplayAll() ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_project(project_id='aprojectid') def test_delete_stack_domain_project_forbidden(self): """Test the delete_stack_domain_project function.""" self._stub_domain_admin_client() self.mock_admin_client.projects = self.m.CreateMockAnything() self.mock_admin_client.projects.get(project='aprojectid').AndRaise( kc_exception.Forbidden) self.m.ReplayAll() ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_project(project_id='aprojectid') def test_delete_stack_domain_project_wrongdomain(self): """Test the delete_stack_domain_project function.""" self._stub_domain_admin_client() self.mock_admin_client.projects = self.m.CreateMockAnything() dummy = self.m.CreateMockAnything() dummy.id = 'aproject123' dummy.domain_id = 'default' self.mock_admin_client.projects.get(project='aprojectid').AndReturn( dummy) self.m.ReplayAll() ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_project(project_id='aprojectid') def test_delete_stack_domain_project_nodomain(self): """Test the delete_stack_domain_project function.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) heat_ks_client.delete_stack_domain_project(project_id='aprojectid') def test_delete_stack_domain_project_legacy_fallback(self): """Test the delete_stack_domain_project function, fallback path.""" cfg.CONF.clear_override('stack_user_domain') ctx = utils.dummy_context() ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertIsNone(heat_ks_client.delete_stack_domain_project( project_id='aprojectid')) def _test_url_for(self, service_url, expected_kwargs, **kwargs): """ Helper function for testing url_for depending on different ways to pass region name. """ self._stubs_v3() self.mock_ks_v3_client.service_catalog = self.m.CreateMockAnything() self.mock_ks_v3_client.service_catalog.url_for(**expected_kwargs)\ .AndReturn(service_url) self.m.ReplayAll() ctx = utils.dummy_context() heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) self.assertEqual(heat_ks_client.url_for(**kwargs), service_url) self.m.VerifyAll() def test_url_for(self): """ Test that None value is passed as region name if region name is not specified in the config file or as one of the arguments. """ cfg.CONF.set_override('region_name_for_services', None) service_url = 'http://example.com:1234/v1' kwargs = { 'region_name': None } self._test_url_for(service_url, kwargs) def test_url_for_with_region(self): """ Test that region name passed as argument is not override by region name specified in the config file. """ cfg.CONF.set_override('region_name_for_services', 'RegionOne') service_url = 'http://regiontwo.example.com:1234/v1' kwargs = { 'region_name': 'RegionTwo' } self._test_url_for(service_url, kwargs, **kwargs) def test_url_for_with_region_name_from_config(self): """ Test that default region name for services from config file is passed if region name is not specified in arguments. """ region_name_for_services = 'RegionOne' cfg.CONF.set_override('region_name_for_services', region_name_for_services) kwargs = { 'region_name': region_name_for_services } service_url = 'http://regionone.example.com:1234/v1' self._test_url_for(service_url, kwargs) heat-2014.1.5/heat/tests/test_cloud_config.py0000664000567000056700000000433412540642614022164 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. import mock from heat.engine import parser from heat.engine import template import heat.engine.resources.software_config.cloud_config as cc from heat.tests.common import HeatTestCase from heat.tests import utils class CloudConfigTest(HeatTestCase): def setUp(self): super(CloudConfigTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() self.properties = { 'cloud_config': {'foo': 'bar'} } self.stack = parser.Stack( self.ctx, 'software_config_test_stack', template.Template({ 'Resources': { 'config_mysql': { 'Type': 'OS::Heat::CloudConfig', 'Properties': self.properties }}})) self.config = self.stack['config_mysql'] heat = mock.MagicMock() self.config.heat = heat self.software_configs = heat.return_value.software_configs def test_resource_mapping(self): mapping = cc.resource_mapping() self.assertEqual(1, len(mapping)) self.assertEqual(cc.CloudConfig, mapping['OS::Heat::CloudConfig']) self.assertIsInstance(self.config, cc.CloudConfig) def test_handle_create(self): sc = mock.MagicMock() config_id = 'c8a19429-7fde-47ea-a42f-40045488226c' sc.id = config_id self.software_configs.create.return_value = sc self.config.handle_create() self.assertEqual(config_id, self.config.resource_id) kwargs = self.software_configs.create.call_args[1] self.assertEqual('#cloud-config\n{foo: bar}\n', kwargs['config']) heat-2014.1.5/heat/tests/test_waitcondition.py0000664000567000056700000007127712540642614022416 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. import datetime import json import time import uuid import mox from oslo.config import cfg from heat.common import identifier from heat.common import template_format import heat.db.api as db_api from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.engine.resources import wait_condition as wc from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils test_template_waitcondition = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a WaitCondition.", "Parameters" : {}, "Resources" : { "WaitHandle" : { "Type" : "AWS::CloudFormation::WaitConditionHandle" }, "WaitForTheHandle" : { "Type" : "AWS::CloudFormation::WaitCondition", "Properties" : { "Handle" : {"Ref" : "WaitHandle"}, "Timeout" : "5" } } } } ''' test_template_wc_count = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a WaitCondition.", "Parameters" : {}, "Resources" : { "WaitHandle" : { "Type" : "AWS::CloudFormation::WaitConditionHandle" }, "WaitForTheHandle" : { "Type" : "AWS::CloudFormation::WaitCondition", "Properties" : { "Handle" : {"Ref" : "WaitHandle"}, "Timeout" : "5", "Count" : "3" } } } } ''' test_template_update_waitcondition = ''' { "HeatTemplateFormatVersion" : "2012-12-12", "Description" : "Updatable Wait Condition", "Parameters" : {}, "Resources" : { "WaitHandle" : { "Type" : "OS::Heat::UpdateWaitConditionHandle" }, "WaitForTheHandle" : { "Type" : "AWS::CloudFormation::WaitCondition", "Properties" : { "Handle" : {"Ref" : "WaitHandle"}, "Timeout" : "5", "Count" : "3" } } } } ''' class WaitConditionTest(HeatTestCase): def setUp(self): super(WaitConditionTest, self).setUp() utils.setup_dummy_db() self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status') cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() def tearDown(self): super(WaitConditionTest, self).tearDown() utils.reset_dummy_db() # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the stack is properly cleaned up def create_stack(self, stack_id=None, template=test_template_waitcondition, params={}, stub=True): temp = template_format.parse(template) template = parser.Template(temp) ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack(ctx, 'test_stack', template, environment.Environment(params), disable_rollback=True) # Stub out the stack ID so we have a known value if stack_id is None: stack_id = str(uuid.uuid4()) self.stack_id = stack_id with utils.UUIDStub(self.stack_id): stack.store() if stub: self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn( self.fc) id = identifier.ResourceIdentifier('test_tenant', stack.name, stack.id, '', 'WaitHandle') self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier') wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id) return stack @utils.stack_delete_after def test_post_success_to_handle(self): self.stack = self.create_stack() wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle', self.stack.id) self.assertEqual('WaitHandle', r.name) self.m.VerifyAll() @utils.stack_delete_after def test_post_failure_to_handle(self): self.stack = self.create_stack() wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn(['FAILURE']) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) reason = rsrc.status_reason self.assertTrue(reason.startswith('WaitConditionFailure:')) r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle', self.stack.id) self.assertEqual('WaitHandle', r.name) self.m.VerifyAll() @utils.stack_delete_after def test_post_success_to_handle_count(self): self.stack = self.create_stack(template=test_template_wc_count) wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS']) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS', 'SUCCESS']) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle', self.stack.id) self.assertEqual('WaitHandle', r.name) self.m.VerifyAll() @utils.stack_delete_after def test_post_failure_to_handle_count(self): self.stack = self.create_stack(template=test_template_wc_count) wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'FAILURE']) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) reason = rsrc.status_reason self.assertTrue(reason.startswith('WaitConditionFailure:')) r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle', self.stack.id) self.assertEqual('WaitHandle', r.name) self.m.VerifyAll() @utils.stack_delete_after def test_timeout(self): st = time.time() self.stack = self.create_stack() # Avoid the stack create exercising the timeout code at the same time self.m.StubOutWithMock(self.stack, 'timeout_secs') self.stack.timeout_secs().MultipleTimes().AndReturn(None) self.m.StubOutWithMock(scheduler, 'wallclock') scheduler.wallclock().AndReturn(st) scheduler.wallclock().AndReturn(st + 0.001) scheduler.wallclock().AndReturn(st + 0.1) wc.WaitConditionHandle.get_status().AndReturn([]) scheduler.wallclock().AndReturn(st + 4.1) wc.WaitConditionHandle.get_status().AndReturn([]) scheduler.wallclock().AndReturn(st + 5.1) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) reason = rsrc.status_reason self.assertTrue(reason.startswith('WaitConditionTimeout:')) self.m.VerifyAll() @utils.stack_delete_after def test_FnGetAtt(self): self.stack = self.create_stack() wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) wc_att = rsrc.FnGetAtt('Data') self.assertEqual(unicode({}), wc_att) handle = self.stack['WaitHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), handle.state) test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '123'} handle.metadata_update(new_metadata=test_metadata) wc_att = rsrc.FnGetAtt('Data') self.assertEqual('{"123": "foo"}', wc_att) test_metadata = {'Data': 'dog', 'Reason': 'cat', 'Status': 'SUCCESS', 'UniqueId': '456'} handle.metadata_update(new_metadata=test_metadata) wc_att = rsrc.FnGetAtt('Data') self.assertEqual(u'{"123": "foo", "456": "dog"}', wc_att) self.m.VerifyAll() @utils.stack_delete_after def test_validate_handle_url_bad_stackid(self): self.m.ReplayAll() stack_id = 'STACK_HUBSID_1234' t = json.loads(test_template_waitcondition) badhandle = ("http://server.test:8000/v1/waitcondition/" + "arn%3Aopenstack%3Aheat%3A%3Atest_tenant" + "%3Astacks%2Ftest_stack%2F" + "bad1" + "%2Fresources%2FWaitHandle") t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle self.stack = self.create_stack(template=json.dumps(t), stub=False, stack_id=stack_id) self.m.ReplayAll() rsrc = self.stack['WaitForTheHandle'] self.assertRaises(ValueError, rsrc.handle_create) self.m.VerifyAll() @utils.stack_delete_after def test_validate_handle_url_bad_stackname(self): self.m.ReplayAll() stack_id = 'STACKABCD1234' t = json.loads(test_template_waitcondition) badhandle = ("http://server.test:8000/v1/waitcondition/" + "arn%3Aopenstack%3Aheat%3A%3Atest_tenant" + "%3Astacks%2FBAD_stack%2F" + stack_id + "%2Fresources%2FWaitHandle") t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle self.stack = self.create_stack(template=json.dumps(t), stub=False, stack_id=stack_id) rsrc = self.stack['WaitForTheHandle'] self.assertRaises(ValueError, rsrc.handle_create) self.m.VerifyAll() @utils.stack_delete_after def test_validate_handle_url_bad_tenant(self): self.m.ReplayAll() stack_id = 'STACKABCD1234' t = json.loads(test_template_waitcondition) badhandle = ("http://server.test:8000/v1/waitcondition/" + "arn%3Aopenstack%3Aheat%3A%3ABAD_tenant" + "%3Astacks%2Ftest_stack%2F" + stack_id + "%2Fresources%2FWaitHandle") t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle self.stack = self.create_stack(stack_id=stack_id, template=json.dumps(t), stub=False) rsrc = self.stack['WaitForTheHandle'] self.assertRaises(ValueError, rsrc.handle_create) self.m.VerifyAll() @utils.stack_delete_after def test_validate_handle_url_bad_resource(self): self.m.ReplayAll() stack_id = 'STACK_HUBR_1234' t = json.loads(test_template_waitcondition) badhandle = ("http://server.test:8000/v1/waitcondition/" + "arn%3Aopenstack%3Aheat%3A%3Atest_tenant" + "%3Astacks%2Ftest_stack%2F" + stack_id + "%2Fresources%2FBADHandle") t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle self.stack = self.create_stack(stack_id=stack_id, template=json.dumps(t), stub=False) rsrc = self.stack['WaitForTheHandle'] self.assertRaises(ValueError, rsrc.handle_create) self.m.VerifyAll() @utils.stack_delete_after def test_validate_handle_url_bad_resource_type(self): self.m.ReplayAll() stack_id = 'STACKABCD1234' t = json.loads(test_template_waitcondition) badhandle = ("http://server.test:8000/v1/waitcondition/" + "arn%3Aopenstack%3Aheat%3A%3Atest_tenant" + "%3Astacks%2Ftest_stack%2F" + stack_id + "%2Fresources%2FWaitForTheHandle") t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle self.stack = self.create_stack(stack_id=stack_id, template=json.dumps(t), stub=False) rsrc = self.stack['WaitForTheHandle'] self.assertRaises(ValueError, rsrc.handle_create) self.m.VerifyAll() class WaitConditionHandleTest(HeatTestCase): def setUp(self): super(WaitConditionHandleTest, self).setUp() cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() utils.setup_dummy_db() def tearDown(self): super(WaitConditionHandleTest, self).tearDown() utils.reset_dummy_db() def create_stack(self, stack_name=None, stack_id=None): temp = template_format.parse(test_template_waitcondition) template = parser.Template(temp) ctx = utils.dummy_context(tenant_id='test_tenant') if stack_name is None: stack_name = utils.random_name() stack = parser.Stack(ctx, stack_name, template, disable_rollback=True) # Stub out the UUID for this test, so we can get an expected signature if stack_id is not None: with utils.UUIDStub(stack_id): stack.store() else: stack.store() self.stack_id = stack.id # Stub waitcondition status so all goes CREATE_COMPLETE self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status') wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) # Stub keystone() with fake client self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn(self.fc) id = identifier.ResourceIdentifier('test_tenant', stack.name, stack.id, '', 'WaitHandle') self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier') wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id) self.m.ReplayAll() stack.create() return stack @utils.stack_delete_after def test_handle(self): stack_id = 'STACKABCD1234' stack_name = 'test_stack2' created_time = datetime.datetime(2012, 11, 29, 13, 49, 37) self.stack = self.create_stack(stack_id=stack_id, stack_name=stack_name) rsrc = self.stack['WaitHandle'] # clear the url db_api.resource_data_set(rsrc, 'ec2_signed_url', None, False) rsrc.created_time = created_time self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) expected_url = "".join([ 'http://server.test:8000/v1/waitcondition/', 'arn%3Aopenstack%3Aheat%3A%3Atest_tenant%3Astacks%2F', 'test_stack2%2F', stack_id, '%2Fresources%2F', 'WaitHandle?', 'Timestamp=2012-11-29T13%3A49%3A37Z&', 'SignatureMethod=HmacSHA256&', 'AWSAccessKeyId=4567&', 'SignatureVersion=2&', 'Signature=', 'fHyt3XFnHq8%2FSwYaVcHdJka1hz6jdK5mHtgbo8OOKbQ%3D']) self.assertEqual(unicode(expected_url), rsrc.FnGetRefId()) self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) self.m.VerifyAll() @utils.stack_delete_after def test_metadata_update(self): self.stack = self.create_stack() rsrc = self.stack['WaitHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '123'} rsrc.metadata_update(new_metadata=test_metadata) handle_metadata = {u'123': {u'Data': u'foo', u'Reason': u'bar', u'Status': u'SUCCESS'}} self.assertEqual(handle_metadata, rsrc.metadata) self.m.VerifyAll() @utils.stack_delete_after def test_metadata_update_invalid(self): self.stack = self.create_stack() rsrc = self.stack['WaitHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) # metadata_update should raise a ValueError if the metadata # is missing any of the expected keys err_metadata = {'Data': 'foo', 'Status': 'SUCCESS', 'UniqueId': '123'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) err_metadata = {'Data': 'foo', 'Reason': 'bar', 'UniqueId': '1234'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) err_metadata = {'Data': 'foo', 'Reason': 'bar', 'UniqueId': '1234'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) err_metadata = {'data': 'foo', 'reason': 'bar', 'status': 'SUCCESS', 'uniqueid': '1234'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) # Also any Status other than SUCCESS or FAILURE should be rejected err_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'UCCESS', 'UniqueId': '123'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) err_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'wibble', 'UniqueId': '123'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) err_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'success', 'UniqueId': '123'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) err_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'FAIL', 'UniqueId': '123'} self.assertRaises(ValueError, rsrc.metadata_update, new_metadata=err_metadata) self.m.VerifyAll() @utils.stack_delete_after def test_get_status(self): self.stack = self.create_stack() rsrc = self.stack['WaitHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) # UnsetStubs, don't want get_status stubbed anymore.. self.m.VerifyAll() self.m.UnsetStubs() self.assertEqual([], rsrc.get_status()) test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '123'} rsrc.metadata_update(new_metadata=test_metadata) self.assertEqual(['SUCCESS'], rsrc.get_status()) test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '456'} rsrc.metadata_update(new_metadata=test_metadata) self.assertEqual(['SUCCESS', 'SUCCESS'], rsrc.get_status()) # re-stub keystone() with fake client or stack delete fails self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn(self.fc) self.m.ReplayAll() @utils.stack_delete_after def test_get_status_reason(self): self.stack = self.create_stack() rsrc = self.stack['WaitHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '123'} rsrc.metadata_update(new_metadata=test_metadata) self.assertEqual('bar', rsrc.get_status_reason('SUCCESS')) test_metadata = {'Data': 'dog', 'Reason': 'cat', 'Status': 'SUCCESS', 'UniqueId': '456'} rsrc.metadata_update(new_metadata=test_metadata) self.assertEqual('bar;cat', rsrc.get_status_reason('SUCCESS')) test_metadata = {'Data': 'boo', 'Reason': 'hoo', 'Status': 'FAILURE', 'UniqueId': '789'} rsrc.metadata_update(new_metadata=test_metadata) self.assertEqual('hoo', rsrc.get_status_reason('FAILURE')) self.m.VerifyAll() class WaitConditionUpdateTest(HeatTestCase): def setUp(self): super(WaitConditionUpdateTest, self).setUp() cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() utils.setup_dummy_db() scheduler.ENABLE_SLEEP = False def tearDown(self): super(WaitConditionUpdateTest, self).tearDown() utils.reset_dummy_db() scheduler.ENABLE_SLEEP = True # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the stack is properly cleaned up def create_stack(self, tmpl=None): if tmpl is None: tmpl = test_template_wc_count temp = template_format.parse(tmpl) template = parser.Template(temp) ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack(ctx, 'test_stack', template, environment.Environment({}), disable_rollback=True) stack_id = str(uuid.uuid4()) self.stack_id = stack_id with utils.UUIDStub(self.stack_id): stack.store() self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn( self.fc) self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status') wc.WaitConditionHandle.get_status().AndReturn([]) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS']) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS']) wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS', 'SUCCESS', 'SUCCESS']) return stack def get_stack(self, stack_id): ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack.load(ctx, stack_id) self.stack_id = stack_id return stack @utils.stack_delete_after def test_update(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() wait_condition_handle = self.stack['WaitHandle'] test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '1'} self._metadata_update(wait_condition_handle, test_metadata, 5) update_snippet = rsrc.parsed_template() update_snippet['Properties']['Count'] = '5' updater = scheduler.TaskRunner(rsrc.update, update_snippet) updater() self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state) @utils.stack_delete_after def test_handle_update(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() wait_condition_handle = self.stack['WaitHandle'] test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '1'} self._metadata_update(wait_condition_handle, test_metadata, 5) update_snippet = {"Type": "AWS::CloudFormation::WaitCondition", "Properties": { "Handle": {"Ref": "WaitHandle"}, "Timeout": "5", "Count": "5"}} prop_diff = {"Count": 5} parsed_snippet = self.stack.resolve_static_data(update_snippet) updater = rsrc.handle_update(parsed_snippet, {}, prop_diff) updater.run_to_completion() self.assertEqual(5, rsrc.properties['Count']) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) @utils.stack_delete_after def test_handle_update_restored_from_db(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() wait_condition_handle = self.stack['WaitHandle'] test_metadata = {'Data': 'foo', 'Reason': 'bar', 'Status': 'SUCCESS', 'UniqueId': '1'} self._metadata_update(wait_condition_handle, test_metadata, 2) self.stack.store() self.stack = self.get_stack(self.stack_id) rsrc = self.stack['WaitForTheHandle'] self._metadata_update(wait_condition_handle, test_metadata, 3) update_snippet = {"Type": "AWS::CloudFormation::WaitCondition", "Properties": { "Handle": {"Ref": "WaitHandle"}, "Timeout": "5", "Count": "5"}} prop_diff = {"Count": 5} parsed_snippet = self.stack.resolve_static_data(update_snippet) updater = rsrc.handle_update(parsed_snippet, {}, prop_diff) updater.run_to_completion() self.assertEqual(5, rsrc.properties['Count']) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) def _metadata_update(self, rsrc, metadata, times=1): for time in range(times): metadata['UniqueId'] = metadata['UniqueId'] * 2 rsrc.metadata_update(new_metadata=metadata) @utils.stack_delete_after def test_handle_update_timeout(self): self.stack = self.create_stack() self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() st = time.time() self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') scheduler.TaskRunner._sleep(mox.IgnoreArg()).MultipleTimes().AndReturn( None) self.m.StubOutWithMock(scheduler, 'wallclock') scheduler.wallclock().AndReturn(st) scheduler.wallclock().AndReturn(st + 0.001) scheduler.wallclock().AndReturn(st + 0.1) scheduler.wallclock().AndReturn(st + 4.1) scheduler.wallclock().AndReturn(st + 5.1) self.m.ReplayAll() update_snippet = {"Type": "AWS::CloudFormation::WaitCondition", "Properties": { "Handle": {"Ref": "WaitHandle"}, "Timeout": "5", "Count": "5"}} prop_diff = {"Count": 5} parsed_snippet = self.stack.resolve_static_data(update_snippet) updater = rsrc.handle_update(parsed_snippet, {}, prop_diff) self.assertEqual(5, rsrc.properties['Count']) self.assertRaises(wc.WaitConditionTimeout, updater.run_to_completion) self.m.VerifyAll() self.m.UnsetStubs() @utils.stack_delete_after def test_update_updatehandle(self): self.stack = self.create_stack(test_template_update_waitcondition) self.m.ReplayAll() self.stack.create() rsrc = self.stack['WaitForTheHandle'] self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) self.m.VerifyAll() self.m.UnsetStubs() wait_condition_handle = self.stack['WaitHandle'] self.assertRaises( resource.UpdateReplace, wait_condition_handle.update, None, None) heat-2014.1.5/heat/tests/test_dependencies.py0000664000567000056700000002046512540642614022162 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. import testtools from heat.engine.dependencies import CircularDependencyException from heat.engine.dependencies import Dependencies class dependenciesTest(testtools.TestCase): def _dep_test(self, func, checkorder, deps): nodes = set.union(*[set(e) for e in deps]) d = Dependencies(deps) order = list(func(d)) for n in nodes: self.assertTrue(n in order, '"%s" is not in the sequence' % n) self.assertEqual(1, order.count(n)) self.assertEqual(len(nodes), len(order)) for l, f in deps: checkorder(order.index(f), order.index(l)) def _dep_test_fwd(self, *deps): def assertLess(a, b): self.assertTrue(a < b, '"%s" is not less than "%s"' % (str(a), str(b))) self._dep_test(iter, assertLess, deps) def _dep_test_rev(self, *deps): def assertGreater(a, b): self.assertTrue(a > b, '"%s" is not greater than "%s"' % (str(a), str(b))) self._dep_test(reversed, assertGreater, deps) def test_edges(self): input_edges = [('1', None), ('2', '3'), ('2', '4')] dp = Dependencies(input_edges) self.assertEqual(set(input_edges), set(dp.graph().edges())) def test_repr(self): dp = Dependencies([('1', None), ('2', '3'), ('2', '4')]) s = "Dependencies([('1', None), ('2', '3'), ('2', '4')])" self.assertEqual(s, repr(dp)) def test_single_node(self): d = Dependencies([('only', None)]) l = list(iter(d)) self.assertEqual(1, len(l)) self.assertEqual('only', l[0]) def test_disjoint(self): d = Dependencies([('1', None), ('2', None)]) l = list(iter(d)) self.assertEqual(2, len(l)) self.assertIn('1', l) self.assertIn('2', l) def test_single_fwd(self): self._dep_test_fwd(('second', 'first')) def test_single_rev(self): self._dep_test_rev(('second', 'first')) def test_chain_fwd(self): self._dep_test_fwd(('third', 'second'), ('second', 'first')) def test_chain_rev(self): self._dep_test_rev(('third', 'second'), ('second', 'first')) def test_diamond_fwd(self): self._dep_test_fwd(('last', 'mid1'), ('last', 'mid2'), ('mid1', 'first'), ('mid2', 'first')) def test_diamond_rev(self): self._dep_test_rev(('last', 'mid1'), ('last', 'mid2'), ('mid1', 'first'), ('mid2', 'first')) def test_complex_fwd(self): self._dep_test_fwd(('last', 'mid1'), ('last', 'mid2'), ('mid1', 'mid3'), ('mid1', 'first'), ('mid3', 'first'), ('mid2', 'first')) def test_complex_rev(self): self._dep_test_rev(('last', 'mid1'), ('last', 'mid2'), ('mid1', 'mid3'), ('mid1', 'first'), ('mid3', 'first'), ('mid2', 'first')) def test_many_edges_fwd(self): self._dep_test_fwd(('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3')) def test_many_edges_rev(self): self._dep_test_rev(('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3')) def test_dbldiamond_fwd(self): self._dep_test_fwd(('last', 'a1'), ('last', 'a2'), ('a1', 'b1'), ('a2', 'b1'), ('a2', 'b2'), ('b1', 'first'), ('b2', 'first')) def test_dbldiamond_rev(self): self._dep_test_rev(('last', 'a1'), ('last', 'a2'), ('a1', 'b1'), ('a2', 'b1'), ('a2', 'b2'), ('b1', 'first'), ('b2', 'first')) def test_circular_fwd(self): d = Dependencies([('first', 'second'), ('second', 'third'), ('third', 'first')]) self.assertRaises(CircularDependencyException, list, iter(d)) def test_circular_rev(self): d = Dependencies([('first', 'second'), ('second', 'third'), ('third', 'first')]) self.assertRaises(CircularDependencyException, list, reversed(d)) def test_self_ref(self): d = Dependencies([('node', 'node')]) self.assertRaises(CircularDependencyException, list, iter(d)) def test_complex_circular_fwd(self): d = Dependencies([('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3'), ('e3', 'mid1')]) self.assertRaises(CircularDependencyException, list, iter(d)) def test_complex_circular_rev(self): d = Dependencies([('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3'), ('e3', 'mid1')]) self.assertRaises(CircularDependencyException, list, reversed(d)) def test_noexist_partial(self): d = Dependencies([('foo', 'bar')]) get = lambda i: d[i] self.assertRaises(KeyError, get, 'baz') def test_single_partial(self): d = Dependencies([('last', 'first')]) p = d['last'] l = list(iter(p)) self.assertEqual(1, len(l)) self.assertEqual('last', l[0]) def test_simple_partial(self): d = Dependencies([('last', 'middle'), ('middle', 'first')]) p = d['middle'] order = list(iter(p)) self.assertEqual(2, len(order)) for n in ('last', 'middle'): self.assertTrue(n in order, "'%s' not found in dependency order" % n) self.assertTrue(order.index('last') > order.index('middle')) def test_simple_multilevel_partial(self): d = Dependencies([('last', 'middle'), ('middle', 'target'), ('target', 'first')]) p = d['target'] order = list(iter(p)) self.assertEqual(3, len(order)) for n in ('last', 'middle', 'target'): self.assertTrue(n in order, "'%s' not found in dependency order" % n) def test_complex_partial(self): d = Dependencies([('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3')]) p = d['mid3'] order = list(iter(p)) self.assertEqual(4, len(order)) for n in ('last', 'mid1', 'mid2', 'mid3'): self.assertTrue(n in order, "'%s' not found in dependency order" % n) def test_required_by(self): d = Dependencies([('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3')]) self.assertEqual(0, len(list(d.required_by('last')))) required_by = list(d.required_by('mid3')) self.assertEqual(2, len(required_by)) for n in ('mid1', 'mid2'): self.assertTrue(n in required_by, "'%s' not found in required_by" % n) required_by = list(d.required_by('e2')) self.assertEqual(1, len(required_by)) self.assertTrue('mid1' in required_by, "'%s' not found in required_by" % n) self.assertRaises(KeyError, d.required_by, 'foo') heat-2014.1.5/heat/tests/test_auth_url.py0000664000567000056700000001007012540642614021346 0ustar jenkinsjenkins00000000000000# Copyright 2013 OpenStack Foundation # # 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. import mock import webob from heat.common import auth_url from heat.tests.common import HeatTestCase class FakeApp(object): """This represents a WSGI app protected by our auth middleware.""" def __call__(self, environ, start_response): """Assert that headers are correctly set up when finally called.""" resp = webob.Response() resp.body = 'SUCCESS' return resp(environ, start_response) class AuthUrlFilterTest(HeatTestCase): def setUp(self): super(AuthUrlFilterTest, self).setUp() self.app = FakeApp() self.config = {'auth_uri': 'foobar'} self.middleware = auth_url.AuthUrlFilter(self.app, self.config) @mock.patch.object(auth_url.cfg, 'CONF') def test_adds_default_auth_url_from_keystone_authtoken(self, mock_cfg): self.config = {} mock_cfg.keystone_authtoken.auth_uri = 'foobar' mock_cfg.auth_password.multi_cloud = False self.middleware = auth_url.AuthUrlFilter(self.app, self.config) req = webob.Request.blank('/tenant_id/') self.middleware(req) self.assertIn('X-Auth-Url', req.headers) self.assertEqual('foobar', req.headers['X-Auth-Url']) def test_overwrites_auth_url_from_headers_with_local_config(self): req = webob.Request.blank('/tenant_id/') req.headers['X-Auth-Url'] = 'should_be_overwritten' self.middleware(req) self.assertEqual('foobar', req.headers['X-Auth-Url']) def test_reads_auth_url_from_local_config(self): req = webob.Request.blank('/tenant_id/') self.middleware(req) self.assertIn('X-Auth-Url', req.headers) self.assertEqual('foobar', req.headers['X-Auth-Url']) @mock.patch.object(auth_url.AuthUrlFilter, '_validate_auth_url') @mock.patch.object(auth_url.cfg, 'CONF') def test_multicloud_reads_auth_url_from_headers(self, mock_cfg, mock_val): mock_cfg.auth_password.multi_cloud = True mock_val.return_value = True req = webob.Request.blank('/tenant_id/') req.headers['X-Auth-Url'] = 'overwrites config' self.middleware(req) self.assertIn('X-Auth-Url', req.headers) self.assertEqual('overwrites config', req.headers['X-Auth-Url']) @mock.patch.object(auth_url.AuthUrlFilter, '_validate_auth_url') @mock.patch.object(auth_url.cfg, 'CONF') def test_multicloud_validates_auth_url(self, mock_cfg, mock_validate): mock_cfg.auth_password.multi_cloud = True req = webob.Request.blank('/tenant_id/') self.middleware(req) self.assertTrue(mock_validate.called) def test_validate_auth_url_with_missing_url(self): self.assertRaises(auth_url.HTTPBadRequest, self.middleware._validate_auth_url, auth_url='') self.assertRaises(auth_url.HTTPBadRequest, self.middleware._validate_auth_url, auth_url=None) @mock.patch.object(auth_url.cfg, 'CONF') def test_validate_auth_url_with_url_not_allowed(self, mock_cfg): mock_cfg.auth_password.allowed_auth_uris = ['foobar'] self.assertRaises(auth_url.HTTPUnauthorized, self.middleware._validate_auth_url, auth_url='not foobar') @mock.patch.object(auth_url.cfg, 'CONF') def test_validate_auth_url_with_valid_url(self, mock_cfg): mock_cfg.auth_password.allowed_auth_uris = ['foobar'] self.assertTrue(self.middleware._validate_auth_url('foobar')) heat-2014.1.5/heat/tests/test_cloudwatch.py0000664000567000056700000000577612540642614021701 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. from mock import patch from heat.common import exception from heat.common import template_format from heat.engine import scheduler from heat.engine import watchrule from heat.tests import common from heat.tests import utils AWS_CloudWatch_Alarm = ''' HeatTemplateFormatVersion: '2012-12-12' Description: Template which tests alarms Resources: test_me: Type: AWS::CloudWatch::Alarm Properties: MetricName: cpu_util Namespace: AWS/EC2 Statistic: Average Period: '60' EvaluationPeriods: '1' Threshold: '50' ComparisonOperator: GreaterThanThreshold ''' class CloudWatchAlarmTest(common.HeatTestCase): def setUp(self): super(CloudWatchAlarmTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() def parse_stack(self): t = template_format.parse(AWS_CloudWatch_Alarm) self.stack = utils.parse_stack(t) return self.stack @utils.stack_delete_after def test_resource_create_good(self): s = self.parse_stack() self.assertIsNone(scheduler.TaskRunner(s['test_me'].create)()) @utils.stack_delete_after def test_resource_create_failed(self): s = self.parse_stack() with patch.object(watchrule.WatchRule, 'store') as bad_store: bad_store.side_effect = KeyError('any random failure') task_func = scheduler.TaskRunner(s['test_me'].create) self.assertRaises(exception.ResourceFailure, task_func) @utils.stack_delete_after def test_resource_delete_good(self): s = self.parse_stack() self.assertIsNone(scheduler.TaskRunner(s['test_me'].create)()) self.assertIsNone(scheduler.TaskRunner(s['test_me'].delete)()) @utils.stack_delete_after @utils.wr_delete_after def test_resource_delete_notfound(self): # if a resource is not found, handle_delete() should not raise # an exception. s = self.parse_stack() self.assertIsNone(scheduler.TaskRunner(s['test_me'].create)()) res_name = self.stack['test_me'].physical_resource_name() self.wr = watchrule.WatchRule.load(self.ctx, watch_name=res_name) with patch.object(watchrule.WatchRule, 'destroy') as bad_destroy: watch_exc = exception.WatchRuleNotFound(watch_name='test') bad_destroy.side_effect = watch_exc self.assertIsNone(scheduler.TaskRunner(s['test_me'].delete)()) heat-2014.1.5/heat/tests/test_constraints.py0000664000567000056700000003101112540642614022070 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. import testtools from heat.engine import constraints from heat.engine import environment class SchemaTest(testtools.TestCase): def test_range_schema(self): d = {'range': {'min': 5, 'max': 10}, 'description': 'a range'} r = constraints.Range(5, 10, description='a range') self.assertEqual(d, dict(r)) def test_range_min_schema(self): d = {'range': {'min': 5}, 'description': 'a range'} r = constraints.Range(min=5, description='a range') self.assertEqual(d, dict(r)) def test_range_max_schema(self): d = {'range': {'max': 10}, 'description': 'a range'} r = constraints.Range(max=10, description='a range') self.assertEqual(d, dict(r)) def test_length_schema(self): d = {'length': {'min': 5, 'max': 10}, 'description': 'a length range'} r = constraints.Length(5, 10, description='a length range') self.assertEqual(d, dict(r)) def test_length_min_schema(self): d = {'length': {'min': 5}, 'description': 'a length range'} r = constraints.Length(min=5, description='a length range') self.assertEqual(d, dict(r)) def test_length_max_schema(self): d = {'length': {'max': 10}, 'description': 'a length range'} r = constraints.Length(max=10, description='a length range') self.assertEqual(d, dict(r)) def test_allowed_values_schema(self): d = {'allowed_values': ['foo', 'bar'], 'description': 'allowed values'} r = constraints.AllowedValues(['foo', 'bar'], description='allowed values') self.assertEqual(d, dict(r)) def test_allowed_pattern_schema(self): d = {'allowed_pattern': '[A-Za-z0-9]', 'description': 'alphanumeric'} r = constraints.AllowedPattern('[A-Za-z0-9]', description='alphanumeric') self.assertEqual(d, dict(r)) def test_range_validate(self): r = constraints.Range(min=5, max=5, description='a range') r.validate(5) def test_range_min_fail(self): r = constraints.Range(min=5, description='a range') self.assertRaises(ValueError, r.validate, 4) def test_range_max_fail(self): r = constraints.Range(max=5, description='a range') self.assertRaises(ValueError, r.validate, 6) def test_length_validate(self): l = constraints.Length(min=5, max=5, description='a range') l.validate('abcde') def test_length_min_fail(self): l = constraints.Length(min=5, description='a range') self.assertRaises(ValueError, l.validate, 'abcd') def test_length_max_fail(self): l = constraints.Length(max=5, description='a range') self.assertRaises(ValueError, l.validate, 'abcdef') def test_schema_all(self): d = { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } s = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) self.assertEqual(d, dict(s)) def test_schema_list_schema(self): d = { 'type': 'list', 'description': 'A list', 'schema': { '*': { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } }, 'required': False, } s = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) l = constraints.Schema(constraints.Schema.LIST, 'A list', schema=s) self.assertEqual(d, dict(l)) def test_schema_map_schema(self): d = { 'type': 'map', 'description': 'A map', 'schema': { 'Foo': { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } }, 'required': False, } s = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) m = constraints.Schema(constraints.Schema.MAP, 'A map', schema={'Foo': s}) self.assertEqual(d, dict(m)) def test_schema_nested_schema(self): d = { 'type': 'list', 'description': 'A list', 'schema': { '*': { 'type': 'map', 'description': 'A map', 'schema': { 'Foo': { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } }, 'required': False, } }, 'required': False, } s = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) m = constraints.Schema(constraints.Schema.MAP, 'A map', schema={'Foo': s}) l = constraints.Schema(constraints.Schema.LIST, 'A list', schema=m) self.assertEqual(d, dict(l)) def test_invalid_type(self): self.assertRaises(constraints.InvalidSchemaError, constraints.Schema, 'Fish') def test_schema_invalid_type(self): self.assertRaises(constraints.InvalidSchemaError, constraints.Schema, 'String', schema=constraints.Schema('String')) def test_range_invalid_type(self): schema = constraints.Schema('String', constraints=[constraints.Range(1, 10)]) err = self.assertRaises(constraints.InvalidSchemaError, schema.validate) self.assertIn('Range constraint invalid for String', str(err)) def test_length_invalid_type(self): schema = constraints.Schema('Integer', constraints=[constraints.Length(1, 10)]) err = self.assertRaises(constraints.InvalidSchemaError, schema.validate) self.assertIn('Length constraint invalid for Integer', str(err)) def test_allowed_pattern_invalid_type(self): schema = constraints.Schema( 'Integer', constraints=[constraints.AllowedPattern('[0-9]*')] ) err = self.assertRaises(constraints.InvalidSchemaError, schema.validate) self.assertIn('AllowedPattern constraint invalid for Integer', str(err)) def test_range_vals_invalid_type(self): self.assertRaises(constraints.InvalidSchemaError, constraints.Range, '1', 10) self.assertRaises(constraints.InvalidSchemaError, constraints.Range, 1, '10') def test_length_vals_invalid_type(self): self.assertRaises(constraints.InvalidSchemaError, constraints.Length, '1', 10) self.assertRaises(constraints.InvalidSchemaError, constraints.Length, 1, '10') def test_schema_validate_good(self): s = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) self.assertIsNone(s.validate()) def test_schema_validate_fail(self): s = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Range(max=4)]) err = self.assertRaises(constraints.InvalidSchemaError, s.validate) self.assertIn('Range constraint invalid for String', str(err)) def test_schema_nested_validate_good(self): nested = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) s = constraints.Schema(constraints.Schema.MAP, 'A map', schema={'Foo': nested}) self.assertIsNone(s.validate()) def test_schema_nested_validate_fail(self): nested = constraints.Schema(constraints.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Range(max=4)]) s = constraints.Schema(constraints.Schema.MAP, 'A map', schema={'Foo': nested}) err = self.assertRaises(constraints.InvalidSchemaError, s.validate) self.assertIn('Range constraint invalid for String', str(err)) class CustomConstraintTest(testtools.TestCase): def setUp(self): super(CustomConstraintTest, self).setUp() self.env = environment.Environment({}) def test_validation(self): class ZeroConstraint(object): def validate(self, value, context): return value == 0 self.env.register_constraint("zero", ZeroConstraint) constraint = constraints.CustomConstraint("zero", environment=self.env) self.assertEqual("Value must be of type zero", str(constraint)) self.assertIsNone(constraint.validate(0)) error = self.assertRaises(ValueError, constraint.validate, 1) self.assertEqual('"1" does not validate zero', str(error)) def test_custom_error(self): class ZeroConstraint(object): def error(self, value): return "%s is not 0" % value def validate(self, value, context): return value == 0 self.env.register_constraint("zero", ZeroConstraint) constraint = constraints.CustomConstraint("zero", environment=self.env) error = self.assertRaises(ValueError, constraint.validate, 1) self.assertEqual("1 is not 0", str(error)) def test_custom_message(self): class ZeroConstraint(object): message = "Only zero!" def validate(self, value, context): return value == 0 self.env.register_constraint("zero", ZeroConstraint) constraint = constraints.CustomConstraint("zero", environment=self.env) self.assertEqual("Only zero!", str(constraint)) def test_unknown_constraint(self): constraint = constraints.CustomConstraint("zero", environment=self.env) error = self.assertRaises(ValueError, constraint.validate, 1) self.assertEqual('"1" does not validate zero (constraint not found)', str(error)) def test_constraints(self): class ZeroConstraint(object): def validate(self, value, context): return value == 0 self.env.register_constraint("zero", ZeroConstraint) constraint = constraints.CustomConstraint("zero", environment=self.env) self.assertEqual("zero", constraint["custom_constraint"]) heat-2014.1.5/heat/tests/test_template_format.py0000664000567000056700000001574112540642614022720 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. import os import mock import testtools import yaml from heat.common import config from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.tests.common import HeatTestCase from heat.tests import utils class JsonToYamlTest(HeatTestCase): def setUp(self): super(JsonToYamlTest, self).setUp() self.expected_test_count = 2 self.longMessage = True self.maxDiff = None def test_convert_all_templates(self): path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'templates') template_test_count = 0 for (json_str, yml_str, file_name) in self.convert_all_json_to_yaml(path): self.compare_json_vs_yaml(json_str, yml_str, file_name) template_test_count += 1 if template_test_count >= self.expected_test_count: break self.assertTrue(template_test_count >= self.expected_test_count, 'Expected at least %d templates to be tested, not %d' % (self.expected_test_count, template_test_count)) def compare_json_vs_yaml(self, json_str, yml_str, file_name): yml = template_format.parse(yml_str) self.assertEqual(u'2012-12-12', yml[u'HeatTemplateFormatVersion'], file_name) self.assertFalse(u'AWSTemplateFormatVersion' in yml, file_name) del(yml[u'HeatTemplateFormatVersion']) jsn = template_format.parse(json_str) if u'AWSTemplateFormatVersion' in jsn: del(jsn[u'AWSTemplateFormatVersion']) self.assertEqual(yml, jsn, file_name) def convert_all_json_to_yaml(self, dirpath): for path in os.listdir(dirpath): if not path.endswith('.template') and not path.endswith('.json'): continue f = open(os.path.join(dirpath, path), 'r') json_str = f.read() yml_str = template_format.convert_json_to_yaml(json_str) yield (json_str, yml_str, f.name) class YamlMinimalTest(HeatTestCase): def _parse_template(self, tmpl_str, msg_str): parse_ex = self.assertRaises(ValueError, template_format.parse, tmpl_str) self.assertIn(msg_str, str(parse_ex)) def test_long_yaml(self): template = {'HeatTemplateFormatVersion': '2012-12-12'} config.cfg.CONF.set_override('max_template_size', 1024) template['Resources'] = ['a'] * (config.cfg.CONF.max_template_size / 3) limit = config.cfg.CONF.max_template_size long_yaml = yaml.safe_dump(template) self.assertTrue(len(long_yaml) > limit) ex = self.assertRaises(exception.RequestLimitExceeded, template_format.parse, long_yaml) msg = ('Request limit exceeded: Template exceeds maximum allowed size ' '(1024 bytes)') self.assertEqual(msg, str(ex)) def test_parse_no_version_format(self): yaml = '' self._parse_template(yaml, 'Template format version not found') yaml2 = '''Parameters: {} Mappings: {} Resources: {} Outputs: {} ''' self._parse_template(yaml2, 'Template format version not found') def test_parse_string_template(self): tmpl_str = 'just string' msg = 'The template is not a JSON object or YAML mapping.' self._parse_template(tmpl_str, msg) def test_parse_invalid_yaml_and_json_template(self): tmpl_str = '{test' msg = 'line 1, column 1' self._parse_template(tmpl_str, msg) def test_parse_json_document(self): tmpl_str = '["foo" , "bar"]' msg = 'The template is not a JSON object or YAML mapping.' self._parse_template(tmpl_str, msg) def test_parse_empty_json_template(self): tmpl_str = '{}' msg = 'Template format version not found' self._parse_template(tmpl_str, msg) def test_parse_yaml_template(self): tmpl_str = 'heat_template_version: 2013-05-23' expected = {'heat_template_version': '2013-05-23'} self.assertEqual(expected, template_format.parse(tmpl_str)) class YamlParseExceptions(HeatTestCase): scenarios = [ ('scanner', dict(raised_exception=yaml.scanner.ScannerError())), ('parser', dict(raised_exception=yaml.parser.ParserError())), ('reader', dict(raised_exception=yaml.reader.ReaderError('', '', '', '', ''))), ] def test_parse_to_value_exception(self): text = 'not important' with mock.patch.object(yaml, 'load') as yaml_loader: yaml_loader.side_effect = self.raised_exception self.assertRaises(ValueError, template_format.parse, text) class JsonYamlResolvedCompareTest(HeatTestCase): def setUp(self): super(JsonYamlResolvedCompareTest, self).setUp() self.longMessage = True self.maxDiff = None utils.setup_dummy_db() def load_template(self, file_name): filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'templates', file_name) f = open(filepath) t = template_format.parse(f.read()) f.close() return t def compare_stacks(self, json_file, yaml_file, parameters): t1 = self.load_template(json_file) t2 = self.load_template(yaml_file) del(t2[u'HeatTemplateFormatVersion']) del(t1[u'AWSTemplateFormatVersion']) stack1 = utils.parse_stack(t1, parameters) stack2 = utils.parse_stack(t2, parameters) # compare resources separately so that resolved static data # is compared t1nr = dict(stack1.t.t) del(t1nr['Resources']) t2nr = dict(stack2.t.t) del(t2nr['Resources']) self.assertEqual(t1nr, t2nr) self.assertEqual(set(stack1.keys()), set(stack2.keys())) for key in stack1: self.assertEqual(stack1[key].t, stack2[key].t) @testtools.skipIf(clients.neutronclient is None, 'neutronclient unavailable') def test_neutron_resolved(self): self.compare_stacks('Neutron.template', 'Neutron.yaml', {}) def test_wordpress_resolved(self): self.compare_stacks('WordPress_Single_Instance.template', 'WordPress_Single_Instance.yaml', {'KeyName': 'test'}) heat-2014.1.5/heat/tests/test_scheduler.py0000664000567000056700000010146412540642614021511 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. import mox import contextlib import eventlet from heat.engine import dependencies from heat.engine import scheduler from heat.tests.common import HeatTestCase class DummyTask(object): def __init__(self, num_steps=3): self.num_steps = num_steps def __call__(self, *args, **kwargs): for i in range(1, self.num_steps + 1): self.do_step(i, *args, **kwargs) yield def do_step(self, step_num, *args, **kwargs): pass class PollingTaskGroupTest(HeatTestCase): def setUp(self): super(PollingTaskGroupTest, self).setUp() self.addCleanup(self.m.VerifyAll) def test_group(self): tasks = [DummyTask() for i in range(3)] for t in tasks: self.m.StubOutWithMock(t, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') for t in tasks: t.do_step(1).AndReturn(None) for t in tasks: scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None) t.do_step(2).AndReturn(None) scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None) t.do_step(3).AndReturn(None) self.m.ReplayAll() tg = scheduler.PollingTaskGroup(tasks) scheduler.TaskRunner(tg)() def test_kwargs(self): input_kwargs = {'i': [0, 1, 2], 'i2': [0, 1, 4]} output_kwargs = scheduler.PollingTaskGroup._kwargs(input_kwargs) expected_kwargs = [{'i': 0, 'i2': 0}, {'i': 1, 'i2': 1}, {'i': 2, 'i2': 4}] self.assertEqual(expected_kwargs, list(output_kwargs)) def test_kwargs_short(self): input_kwargs = {'i': [0, 1, 2], 'i2': [0]} output_kwargs = scheduler.PollingTaskGroup._kwargs(input_kwargs) expected_kwargs = [{'i': 0, 'i2': 0}] self.assertEqual(expected_kwargs, list(output_kwargs)) def test_no_kwargs(self): output_kwargs = scheduler.PollingTaskGroup._kwargs({}) self.assertEqual([], list(output_kwargs)) def test_args(self): input_args = ([0, 1, 2], [0, 1, 4]) output_args = scheduler.PollingTaskGroup._args(input_args) expected_args = [(0, 0), (1, 1), (2, 4)] self.assertEqual(expected_args, list(output_args)) def test_args_short(self): input_args = ([0, 1, 2], [0]) output_args = scheduler.PollingTaskGroup._args(input_args) expected_args = [(0, 0)] self.assertEqual(expected_args, list(output_args)) def test_no_args(self): output_args = scheduler.PollingTaskGroup._args([]) self.assertEqual([], list(output_args)) @contextlib.contextmanager def _args_test(self, *arg_lists, **kwarg_lists): dummy = DummyTask(1) tg = scheduler.PollingTaskGroup.from_task_with_args(dummy, *arg_lists, **kwarg_lists) self.m.StubOutWithMock(dummy, 'do_step') yield dummy self.m.ReplayAll() scheduler.TaskRunner(tg)(wait_time=None) def test_with_all_args(self): with self._args_test([0, 1, 2], [0, 1, 8], i=[0, 1, 2], i2=[0, 1, 4]) as dummy: for i in range(3): dummy.do_step(1, i, i * i * i, i=i, i2=i * i) def test_with_short_args(self): with self._args_test([0, 1, 2], [0, 1], i=[0, 1, 2], i2=[0, 1, 4]) as dummy: for i in range(2): dummy.do_step(1, i, i * i, i=i, i2=i * i) def test_with_short_kwargs(self): with self._args_test([0, 1, 2], [0, 1, 8], i=[0, 1], i2=[0, 1, 4]) as dummy: for i in range(2): dummy.do_step(1, i, i * i, i=i, i2=i * i) def test_with_empty_args(self): with self._args_test([], i=[0, 1, 2], i2=[0, 1, 4]): pass def test_with_empty_kwargs(self): with self._args_test([0, 1, 2], [0, 1, 8], i=[]): pass def test_with_no_args(self): with self._args_test(i=[0, 1, 2], i2=[0, 1, 4]) as dummy: for i in range(3): dummy.do_step(1, i=i, i2=i * i) def test_with_no_kwargs(self): with self._args_test([0, 1, 2], [0, 1, 4]) as dummy: for i in range(3): dummy.do_step(1, i, i * i) class ExceptionGroupTest(HeatTestCase): def test_contains_exceptions(self): exception_group = scheduler.ExceptionGroup() self.assertIsInstance(exception_group.exceptions, list) def test_can_be_initialized_with_a_list_of_exceptions(self): ex1 = Exception("ex 1") ex2 = Exception("ex 2") exception_group = scheduler.ExceptionGroup([ex1, ex2]) self.assertIn(ex1, exception_group.exceptions) self.assertIn(ex2, exception_group.exceptions) def test_can_add_exceptions_after_init(self): ex = Exception() exception_group = scheduler.ExceptionGroup() exception_group.exceptions.append(ex) self.assertIn(ex, exception_group.exceptions) def test_str_representation_aggregates_all_exceptions(self): ex1 = Exception("ex 1") ex2 = Exception("ex 2") exception_group = scheduler.ExceptionGroup([ex1, ex2]) self.assertEqual("['ex 1', 'ex 2']", str(exception_group)) class DependencyTaskGroupTest(HeatTestCase): def setUp(self): super(DependencyTaskGroupTest, self).setUp() self.addCleanup(self.m.VerifyAll) self.aggregate_exceptions = False self.reverse_order = False @contextlib.contextmanager def _dep_test(self, *edges): dummy = DummyTask(getattr(self, 'steps', 3)) deps = dependencies.Dependencies(edges) tg = scheduler.DependencyTaskGroup( deps, dummy, aggregate_exceptions=self.aggregate_exceptions, reverse=self.reverse_order) self.m.StubOutWithMock(dummy, 'do_step') yield dummy self.m.ReplayAll() scheduler.TaskRunner(tg)(wait_time=None) def test_no_steps(self): self.steps = 0 self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') with self._dep_test(('second', 'first')): scheduler.TaskRunner._sleep(None).AndReturn(None) def test_single_node(self): with self._dep_test(('only', None)) as dummy: dummy.do_step(1, 'only').AndReturn(None) dummy.do_step(2, 'only').AndReturn(None) dummy.do_step(3, 'only').AndReturn(None) def test_disjoint(self): with self._dep_test(('1', None), ('2', None)) as dummy: dummy.do_step(1, '1').InAnyOrder('1') dummy.do_step(1, '2').InAnyOrder('1') dummy.do_step(2, '1').InAnyOrder('2') dummy.do_step(2, '2').InAnyOrder('2') dummy.do_step(3, '1').InAnyOrder('3') dummy.do_step(3, '2').InAnyOrder('3') def test_single_fwd(self): with self._dep_test(('second', 'first')) as dummy: dummy.do_step(1, 'first').AndReturn(None) dummy.do_step(2, 'first').AndReturn(None) dummy.do_step(3, 'first').AndReturn(None) dummy.do_step(1, 'second').AndReturn(None) dummy.do_step(2, 'second').AndReturn(None) dummy.do_step(3, 'second').AndReturn(None) def test_chain_fwd(self): with self._dep_test(('third', 'second'), ('second', 'first')) as dummy: dummy.do_step(1, 'first').AndReturn(None) dummy.do_step(2, 'first').AndReturn(None) dummy.do_step(3, 'first').AndReturn(None) dummy.do_step(1, 'second').AndReturn(None) dummy.do_step(2, 'second').AndReturn(None) dummy.do_step(3, 'second').AndReturn(None) dummy.do_step(1, 'third').AndReturn(None) dummy.do_step(2, 'third').AndReturn(None) dummy.do_step(3, 'third').AndReturn(None) def test_diamond_fwd(self): with self._dep_test(('last', 'mid1'), ('last', 'mid2'), ('mid1', 'first'), ('mid2', 'first')) as dummy: dummy.do_step(1, 'first').AndReturn(None) dummy.do_step(2, 'first').AndReturn(None) dummy.do_step(3, 'first').AndReturn(None) dummy.do_step(1, 'mid1').InAnyOrder('1') dummy.do_step(1, 'mid2').InAnyOrder('1') dummy.do_step(2, 'mid1').InAnyOrder('2') dummy.do_step(2, 'mid2').InAnyOrder('2') dummy.do_step(3, 'mid1').InAnyOrder('3') dummy.do_step(3, 'mid2').InAnyOrder('3') dummy.do_step(1, 'last').AndReturn(None) dummy.do_step(2, 'last').AndReturn(None) dummy.do_step(3, 'last').AndReturn(None) def test_complex_fwd(self): with self._dep_test(('last', 'mid1'), ('last', 'mid2'), ('mid1', 'mid3'), ('mid1', 'first'), ('mid3', 'first'), ('mid2', 'first')) as dummy: dummy.do_step(1, 'first').AndReturn(None) dummy.do_step(2, 'first').AndReturn(None) dummy.do_step(3, 'first').AndReturn(None) dummy.do_step(1, 'mid2').InAnyOrder('1') dummy.do_step(1, 'mid3').InAnyOrder('1') dummy.do_step(2, 'mid2').InAnyOrder('2') dummy.do_step(2, 'mid3').InAnyOrder('2') dummy.do_step(3, 'mid2').InAnyOrder('3') dummy.do_step(3, 'mid3').InAnyOrder('3') dummy.do_step(1, 'mid1').AndReturn(None) dummy.do_step(2, 'mid1').AndReturn(None) dummy.do_step(3, 'mid1').AndReturn(None) dummy.do_step(1, 'last').AndReturn(None) dummy.do_step(2, 'last').AndReturn(None) dummy.do_step(3, 'last').AndReturn(None) def test_many_edges_fwd(self): with self._dep_test(('last', 'e1'), ('last', 'mid1'), ('last', 'mid2'), ('mid1', 'e2'), ('mid1', 'mid3'), ('mid2', 'mid3'), ('mid3', 'e3')) as dummy: dummy.do_step(1, 'e1').InAnyOrder('1edges') dummy.do_step(1, 'e2').InAnyOrder('1edges') dummy.do_step(1, 'e3').InAnyOrder('1edges') dummy.do_step(2, 'e1').InAnyOrder('2edges') dummy.do_step(2, 'e2').InAnyOrder('2edges') dummy.do_step(2, 'e3').InAnyOrder('2edges') dummy.do_step(3, 'e1').InAnyOrder('3edges') dummy.do_step(3, 'e2').InAnyOrder('3edges') dummy.do_step(3, 'e3').InAnyOrder('3edges') dummy.do_step(1, 'mid3').AndReturn(None) dummy.do_step(2, 'mid3').AndReturn(None) dummy.do_step(3, 'mid3').AndReturn(None) dummy.do_step(1, 'mid2').InAnyOrder('1mid') dummy.do_step(1, 'mid1').InAnyOrder('1mid') dummy.do_step(2, 'mid2').InAnyOrder('2mid') dummy.do_step(2, 'mid1').InAnyOrder('2mid') dummy.do_step(3, 'mid2').InAnyOrder('3mid') dummy.do_step(3, 'mid1').InAnyOrder('3mid') dummy.do_step(1, 'last').AndReturn(None) dummy.do_step(2, 'last').AndReturn(None) dummy.do_step(3, 'last').AndReturn(None) def test_dbldiamond_fwd(self): with self._dep_test(('last', 'a1'), ('last', 'a2'), ('a1', 'b1'), ('a2', 'b1'), ('a2', 'b2'), ('b1', 'first'), ('b2', 'first')) as dummy: dummy.do_step(1, 'first').AndReturn(None) dummy.do_step(2, 'first').AndReturn(None) dummy.do_step(3, 'first').AndReturn(None) dummy.do_step(1, 'b1').InAnyOrder('1b') dummy.do_step(1, 'b2').InAnyOrder('1b') dummy.do_step(2, 'b1').InAnyOrder('2b') dummy.do_step(2, 'b2').InAnyOrder('2b') dummy.do_step(3, 'b1').InAnyOrder('3b') dummy.do_step(3, 'b2').InAnyOrder('3b') dummy.do_step(1, 'a1').InAnyOrder('1a') dummy.do_step(1, 'a2').InAnyOrder('1a') dummy.do_step(2, 'a1').InAnyOrder('2a') dummy.do_step(2, 'a2').InAnyOrder('2a') dummy.do_step(3, 'a1').InAnyOrder('3a') dummy.do_step(3, 'a2').InAnyOrder('3a') dummy.do_step(1, 'last').AndReturn(None) dummy.do_step(2, 'last').AndReturn(None) dummy.do_step(3, 'last').AndReturn(None) def test_circular_deps(self): d = dependencies.Dependencies([('first', 'second'), ('second', 'third'), ('third', 'first')]) self.assertRaises(dependencies.CircularDependencyException, scheduler.DependencyTaskGroup, d) def test_aggregate_exceptions_raises_all_at_the_end(self): def run_tasks_with_exceptions(e1=None, e2=None): self.aggregate_exceptions = True tasks = (('A', None), ('B', None), ('C', None)) with self._dep_test(*tasks) as dummy: dummy.do_step(1, 'A').InAnyOrder('1') dummy.do_step(1, 'B').InAnyOrder('1') dummy.do_step(1, 'C').InAnyOrder('1').AndRaise(e1) dummy.do_step(2, 'A').InAnyOrder('2') dummy.do_step(2, 'B').InAnyOrder('2').AndRaise(e2) dummy.do_step(3, 'A').InAnyOrder('3') e1 = Exception('e1') e2 = Exception('e2') exc = self.assertRaises(scheduler.ExceptionGroup, run_tasks_with_exceptions, e1, e2) self.assertEqual(set([e1, e2]), set(exc.exceptions)) def test_aggregate_exceptions_cancels_dependent_tasks_recursively(self): def run_tasks_with_exceptions(e1=None, e2=None): self.aggregate_exceptions = True tasks = (('A', None), ('B', 'A'), ('C', 'B')) with self._dep_test(*tasks) as dummy: dummy.do_step(1, 'A').AndRaise(e1) e1 = Exception('e1') exc = self.assertRaises(scheduler.ExceptionGroup, run_tasks_with_exceptions, e1) self.assertEqual([e1], exc.exceptions) def test_aggregate_exceptions_cancels_tasks_in_reverse_order(self): def run_tasks_with_exceptions(e1=None, e2=None): self.reverse_order = True self.aggregate_exceptions = True tasks = (('A', None), ('B', 'A'), ('C', 'B')) with self._dep_test(*tasks) as dummy: dummy.do_step(1, 'C').AndRaise(e1) e1 = Exception('e1') exc = self.assertRaises(scheduler.ExceptionGroup, run_tasks_with_exceptions, e1) self.assertEqual([e1], exc.exceptions) class TaskTest(HeatTestCase): def setUp(self): super(TaskTest, self).setUp() scheduler.ENABLE_SLEEP = True self.addCleanup(self.m.VerifyAll) def test_run(self): task = DummyTask() self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') task.do_step(1).AndReturn(None) scheduler.TaskRunner._sleep(1).AndReturn(None) task.do_step(2).AndReturn(None) scheduler.TaskRunner._sleep(1).AndReturn(None) task.do_step(3).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(task)() def test_run_wait_time(self): task = DummyTask() self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') task.do_step(1).AndReturn(None) scheduler.TaskRunner._sleep(42).AndReturn(None) task.do_step(2).AndReturn(None) scheduler.TaskRunner._sleep(42).AndReturn(None) task.do_step(3).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(task)(wait_time=42) def test_start_run(self): task = DummyTask() self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') task.do_step(1).AndReturn(None) scheduler.TaskRunner._sleep(1).AndReturn(None) task.do_step(2).AndReturn(None) scheduler.TaskRunner._sleep(1).AndReturn(None) task.do_step(3).AndReturn(None) self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start() runner.run_to_completion() def test_start_run_wait_time(self): task = DummyTask() self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') task.do_step(1).AndReturn(None) scheduler.TaskRunner._sleep(24).AndReturn(None) task.do_step(2).AndReturn(None) scheduler.TaskRunner._sleep(24).AndReturn(None) task.do_step(3).AndReturn(None) self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start() runner.run_to_completion(wait_time=24) def test_sleep(self): sleep_time = 42 self.m.StubOutWithMock(eventlet, 'sleep') eventlet.sleep(sleep_time).MultipleTimes().AndReturn(None) self.m.ReplayAll() runner = scheduler.TaskRunner(DummyTask()) runner(wait_time=sleep_time) def test_sleep_zero(self): self.m.StubOutWithMock(eventlet, 'sleep') eventlet.sleep(0).MultipleTimes().AndReturn(None) self.m.ReplayAll() runner = scheduler.TaskRunner(DummyTask()) runner(wait_time=0) def test_sleep_none(self): self.m.StubOutWithMock(eventlet, 'sleep') self.m.ReplayAll() runner = scheduler.TaskRunner(DummyTask()) runner(wait_time=None) def test_args(self): args = ['foo', 'bar'] kwargs = {'baz': 'quux', 'blarg': 'wibble'} self.m.StubOutWithMock(DummyTask, '__call__') task = DummyTask() task(*args, **kwargs) self.m.ReplayAll() runner = scheduler.TaskRunner(task, *args, **kwargs) runner(wait_time=None) def test_non_callable(self): self.assertRaises(AssertionError, scheduler.TaskRunner, object()) def test_stepping(self): task = DummyTask() self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') task.do_step(1).AndReturn(None) task.do_step(2).AndReturn(None) task.do_step(3).AndReturn(None) self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start() self.assertFalse(runner.step()) self.assertTrue(runner) self.assertFalse(runner.step()) self.assertTrue(runner.step()) self.assertFalse(runner) def test_start_no_steps(self): task = DummyTask(0) self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start() self.assertTrue(runner.done()) self.assertTrue(runner.step()) def test_start_only(self): task = DummyTask() self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') task.do_step(1).AndReturn(None) self.m.ReplayAll() runner = scheduler.TaskRunner(task) self.assertFalse(runner.started()) runner.start() self.assertTrue(runner.started()) def test_double_start(self): runner = scheduler.TaskRunner(DummyTask()) runner.start() self.assertRaises(AssertionError, runner.start) def test_call_double_start(self): runner = scheduler.TaskRunner(DummyTask()) runner(wait_time=None) self.assertRaises(AssertionError, runner.start) def test_start_function(self): def task(): pass runner = scheduler.TaskRunner(task) runner.start() self.assertTrue(runner.started()) self.assertTrue(runner.done()) self.assertTrue(runner.step()) def test_repeated_done(self): task = DummyTask(0) self.m.StubOutWithMock(task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start() self.assertTrue(runner.step()) self.assertTrue(runner.step()) def test_timeout(self): st = scheduler.wallclock() def task(): while True: yield self.m.StubOutWithMock(scheduler, 'wallclock') scheduler.wallclock().AndReturn(st) scheduler.wallclock().AndReturn(st + 0.5) scheduler.wallclock().AndReturn(st + 1.5) self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start(timeout=1) self.assertTrue(runner) self.assertRaises(scheduler.Timeout, runner.step) def test_timeout_return(self): st = scheduler.wallclock() def task(): while True: try: yield except scheduler.Timeout: return self.m.StubOutWithMock(scheduler, 'wallclock') scheduler.wallclock().AndReturn(st) scheduler.wallclock().AndReturn(st + 0.5) scheduler.wallclock().AndReturn(st + 1.5) self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start(timeout=1) self.assertTrue(runner) self.assertTrue(runner.step()) self.assertFalse(runner) def test_timeout_swallowed(self): st = scheduler.wallclock() def task(): while True: try: yield except scheduler.Timeout: yield self.fail('Task still running') self.m.StubOutWithMock(scheduler, 'wallclock') scheduler.wallclock().AndReturn(st) scheduler.wallclock().AndReturn(st + 0.5) scheduler.wallclock().AndReturn(st + 1.5) self.m.ReplayAll() runner = scheduler.TaskRunner(task) runner.start(timeout=1) self.assertTrue(runner) self.assertTrue(runner.step()) self.assertFalse(runner) self.assertTrue(runner.step()) class DescriptionTest(HeatTestCase): def setUp(self): super(DescriptionTest, self).setUp() self.addCleanup(self.m.VerifyAll) def test_func(self): def f(): pass self.assertEqual('f', scheduler.task_description(f)) def test_lambda(self): l = lambda: None self.assertEqual('', scheduler.task_description(l)) def test_method(self): class C(object): def __str__(self): return 'C "o"' def __repr__(self): return 'o' def m(self): pass self.assertEqual('m from C "o"', scheduler.task_description(C().m)) def test_object(self): class C(object): def __str__(self): return 'C "o"' def __repr__(self): return 'o' def __call__(self): pass self.assertEqual('o', scheduler.task_description(C())) class WrapperTaskTest(HeatTestCase): def setUp(self): super(WrapperTaskTest, self).setUp() self.addCleanup(self.m.VerifyAll) def test_wrap(self): child_tasks = [DummyTask() for i in range(3)] @scheduler.wrappertask def task(): for child_task in child_tasks: yield child_task() yield for child_task in child_tasks: self.m.StubOutWithMock(child_task, 'do_step') self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') for child_task in child_tasks: child_task.do_step(1).AndReturn(None) scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None) child_task.do_step(2).AndReturn(None) scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None) child_task.do_step(3).AndReturn(None) scheduler.TaskRunner._sleep(mox.IsA(int)).AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(task)() def test_child_exception(self): class MyException(Exception): pass def child_task(): yield raise MyException() @scheduler.wrappertask def parent_task(): try: yield child_task() except MyException: raise else: self.fail('No exception raised in parent_task') task = parent_task() task.next() self.assertRaises(MyException, task.next) def test_child_exception_exit(self): class MyException(Exception): pass def child_task(): yield raise MyException() @scheduler.wrappertask def parent_task(): try: yield child_task() except MyException: return else: self.fail('No exception raised in parent_task') task = parent_task() task.next() self.assertRaises(StopIteration, task.next) def test_child_exception_swallow(self): class MyException(Exception): pass def child_task(): yield raise MyException() @scheduler.wrappertask def parent_task(): try: yield child_task() except MyException: yield else: self.fail('No exception raised in parent_task') yield task = parent_task() task.next() task.next() def test_child_exception_swallow_next(self): class MyException(Exception): pass def child_task(): yield raise MyException() dummy = DummyTask() @scheduler.wrappertask def parent_task(): try: yield child_task() except MyException: pass else: self.fail('No exception raised in parent_task') yield dummy() task = parent_task() task.next() self.m.StubOutWithMock(dummy, 'do_step') for i in range(1, dummy.num_steps + 1): dummy.do_step(i).AndReturn(None) self.m.ReplayAll() for i in range(1, dummy.num_steps + 1): task.next() self.assertRaises(StopIteration, task.next) def test_thrown_exception_swallow_next(self): class MyException(Exception): pass dummy = DummyTask() @scheduler.wrappertask def child_task(): try: yield except MyException: yield dummy() else: self.fail('No exception raised in child_task') @scheduler.wrappertask def parent_task(): yield child_task() task = parent_task() self.m.StubOutWithMock(dummy, 'do_step') for i in range(1, dummy.num_steps + 1): dummy.do_step(i).AndReturn(None) self.m.ReplayAll() next(task) task.throw(MyException) for i in range(2, dummy.num_steps + 1): task.next() self.assertRaises(StopIteration, task.next) def test_thrown_exception_raise(self): class MyException(Exception): pass dummy = DummyTask() @scheduler.wrappertask def child_task(): try: yield except MyException: raise else: self.fail('No exception raised in child_task') @scheduler.wrappertask def parent_task(): try: yield child_task() except MyException: yield dummy() task = parent_task() self.m.StubOutWithMock(dummy, 'do_step') for i in range(1, dummy.num_steps + 1): dummy.do_step(i).AndReturn(None) self.m.ReplayAll() next(task) task.throw(MyException) for i in range(2, dummy.num_steps + 1): task.next() self.assertRaises(StopIteration, task.next) def test_thrown_exception_exit(self): class MyException(Exception): pass dummy = DummyTask() @scheduler.wrappertask def child_task(): try: yield except MyException: return else: self.fail('No exception raised in child_task') @scheduler.wrappertask def parent_task(): yield child_task() yield dummy() task = parent_task() self.m.StubOutWithMock(dummy, 'do_step') for i in range(1, dummy.num_steps + 1): dummy.do_step(i).AndReturn(None) self.m.ReplayAll() next(task) task.throw(MyException) for i in range(2, dummy.num_steps + 1): task.next() self.assertRaises(StopIteration, task.next) def test_parent_exception(self): class MyException(Exception): pass def child_task(): yield @scheduler.wrappertask def parent_task(): yield child_task() raise MyException() task = parent_task() task.next() self.assertRaises(MyException, task.next) def test_parent_throw(self): class MyException(Exception): pass @scheduler.wrappertask def parent_task(): try: yield DummyTask()() except MyException: raise else: self.fail('No exception raised in parent_task') task = parent_task() task.next() self.assertRaises(MyException, task.throw, MyException()) def test_parent_throw_exit(self): class MyException(Exception): pass @scheduler.wrappertask def parent_task(): try: yield DummyTask()() except MyException: return else: self.fail('No exception raised in parent_task') task = parent_task() task.next() self.assertRaises(StopIteration, task.throw, MyException()) def test_parent_cancel(self): @scheduler.wrappertask def parent_task(): try: yield except GeneratorExit: raise else: self.fail('parent_task not closed') task = parent_task() task.next() task.close() def test_parent_cancel_exit(self): @scheduler.wrappertask def parent_task(): try: yield except GeneratorExit: return else: self.fail('parent_task not closed') task = parent_task() task.next() task.close() def test_cancel(self): def child_task(): try: yield except GeneratorExit: raise else: self.fail('child_task not closed') @scheduler.wrappertask def parent_task(): try: yield child_task() except GeneratorExit: raise else: self.fail('parent_task not closed') task = parent_task() task.next() task.close() def test_cancel_exit(self): def child_task(): try: yield except GeneratorExit: return else: self.fail('child_task not closed') @scheduler.wrappertask def parent_task(): try: yield child_task() except GeneratorExit: raise else: self.fail('parent_task not closed') task = parent_task() task.next() task.close() def test_cancel_parent_exit(self): def child_task(): try: yield except GeneratorExit: return else: self.fail('child_task not closed') @scheduler.wrappertask def parent_task(): try: yield child_task() except GeneratorExit: return else: self.fail('parent_task not closed') task = parent_task() task.next() task.close() heat-2014.1.5/heat/tests/test_instance_group_update_policy.py0000664000567000056700000006653512540642614025505 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. import copy import json import mox from testtools.matchers import MatchesRegex from heat.common import exception from heat.common import template_format from heat.engine import parser from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import nova_keypair from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes ig_tmpl_without_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create multiple instances.", "Parameters" : {}, "Resources" : { "JobServerGroup" : { "Type" : "OS::Heat::InstanceGroup", "Properties" : { "LaunchConfigurationName" : { "Ref" : "JobServerConfig" }, "Size" : "10", "AvailabilityZones" : ["nova"] } }, "JobServerConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' ig_tmpl_with_bad_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create multiple instances.", "Parameters" : {}, "Resources" : { "JobServerGroup" : { "UpdatePolicy" : { "RollingUpdate": "foo" }, "Type" : "OS::Heat::InstanceGroup", "Properties" : { "LaunchConfigurationName" : { "Ref" : "JobServerConfig" }, "Size" : "10", "AvailabilityZones" : ["nova"] } }, "JobServerConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' ig_tmpl_with_default_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create multiple instances.", "Parameters" : {}, "Resources" : { "JobServerGroup" : { "UpdatePolicy" : { "RollingUpdate" : { } }, "Type" : "OS::Heat::InstanceGroup", "Properties" : { "LaunchConfigurationName" : { "Ref" : "JobServerConfig" }, "Size" : "10", "AvailabilityZones" : ["nova"] } }, "JobServerConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' ig_tmpl_with_updt_policy = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to create multiple instances.", "Parameters" : {}, "Resources" : { "JobServerGroup" : { "UpdatePolicy" : { "RollingUpdate" : { "MinInstancesInService" : "1", "MaxBatchSize" : "2", "PauseTime" : "PT1S" } }, "Type" : "OS::Heat::InstanceGroup", "Properties" : { "LaunchConfigurationName" : { "Ref" : "JobServerConfig" }, "Size" : "10", "AvailabilityZones" : ["nova"] } }, "JobServerConfig" : { "Type" : "AWS::AutoScaling::LaunchConfiguration", "Properties": { "ImageId" : "foo", "InstanceType" : "m1.medium", "KeyName" : "test", "SecurityGroups" : [ "sg-1" ], "UserData" : "jsconfig data" } } } } ''' class InstanceGroupTest(HeatTestCase): def setUp(self): super(InstanceGroupTest, self).setUp() self.fc = fakes.FakeClient() utils.setup_dummy_db() def _stub_validate(self): self.m.StubOutWithMock(parser.Stack, 'validate') parser.Stack.validate().MultipleTimes() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) def _stub_grp_create(self, capacity): """ Expect creation of instances to capacity """ self._stub_validate() self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') cookie = object() for x in range(capacity): instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(True) def _stub_grp_replace(self, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0): """ Expect update replacement of the instances """ self._stub_validate() self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') self.m.StubOutWithMock(instance.Instance, 'destroy') cookie = object() for i in range(num_creates_expected_on_updt): instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(True) for i in range(num_deletes_expected_on_updt): instance.Instance.destroy().AndReturn(None) def _stub_grp_update(self, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0): """ Expect update of the instances """ self.m.StubOutWithMock(instance.Instance, 'nova') instance.Instance.nova().MultipleTimes().AndReturn(self.fc) def activate_status(server): server.status = 'VERIFY_RESIZE' return_server = self.fc.servers.list()[1] return_server.id = 1234 return_server.get = activate_status.__get__(return_server) self.m.StubOutWithMock(self.fc.servers, 'get') self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') self.fc.servers.get(mox.IgnoreArg()).\ MultipleTimes().AndReturn(return_server) self.fc.client.post_servers_1234_action( body={'resize': {'flavorRef': 3}}).\ MultipleTimes().AndReturn((202, None)) self.fc.client.post_servers_1234_action( body={'confirmResize': None}).\ MultipleTimes().AndReturn((202, None)) self._stub_grp_replace(num_creates_expected_on_updt, num_deletes_expected_on_updt) def get_launch_conf_name(self, stack, ig_name): return stack[ig_name].properties['LaunchConfigurationName'] def test_parse_without_update_policy(self): tmpl = template_format.parse(ig_tmpl_without_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() grp = stack['JobServerGroup'] self.assertFalse(grp.update_policy['RollingUpdate']) def test_parse_with_update_policy(self): tmpl = template_format.parse(ig_tmpl_with_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() grp = stack['JobServerGroup'] self.assertTrue(grp.update_policy) self.assertEqual(1, len(grp.update_policy)) self.assertIn('RollingUpdate', grp.update_policy) policy = grp.update_policy['RollingUpdate'] self.assertTrue(policy and len(policy) > 0) self.assertEqual(1, int(policy['MinInstancesInService'])) self.assertEqual(2, int(policy['MaxBatchSize'])) self.assertEqual('PT1S', policy['PauseTime']) def test_parse_with_default_update_policy(self): tmpl = template_format.parse(ig_tmpl_with_default_updt_policy) stack = utils.parse_stack(tmpl) stack.validate() grp = stack['JobServerGroup'] self.assertTrue(grp.update_policy) self.assertEqual(1, len(grp.update_policy)) self.assertIn('RollingUpdate', grp.update_policy) policy = grp.update_policy['RollingUpdate'] self.assertTrue(policy and len(policy) > 0) self.assertEqual(0, int(policy['MinInstancesInService'])) self.assertEqual(1, int(policy['MaxBatchSize'])) self.assertEqual('PT0S', policy['PauseTime']) def test_parse_with_bad_update_policy(self): tmpl = template_format.parse(ig_tmpl_with_bad_updt_policy) stack = utils.parse_stack(tmpl) self.assertRaises(exception.StackValidationFailed, stack.validate) def test_parse_with_bad_pausetime_in_update_policy(self): tmpl = template_format.parse(ig_tmpl_with_updt_policy) group = tmpl['Resources']['JobServerGroup'] policy = group['UpdatePolicy']['RollingUpdate'] # test against some random string policy['PauseTime'] = 'ABCD1234' stack = utils.parse_stack(tmpl) self.assertRaises(exception.StackValidationFailed, stack.validate) # test unsupported designator policy['PauseTime'] = 'P1YT1H' stack = utils.parse_stack(tmpl) self.assertRaises(exception.StackValidationFailed, stack.validate) def validate_update_policy_diff(self, current, updated): # load current stack current_tmpl = template_format.parse(current) current_stack = utils.parse_stack(current_tmpl) # get the json snippet for the current InstanceGroup resource current_grp = current_stack['JobServerGroup'] current_snippets = dict((n, r.parsed_template()) for n, r in current_stack.items()) current_grp_json = current_snippets[current_grp.name] # load the updated stack updated_tmpl = template_format.parse(updated) updated_stack = utils.parse_stack(updated_tmpl) # get the updated json snippet for the InstanceGroup resource in the # context of the current stack updated_grp = updated_stack['JobServerGroup'] updated_grp_json = current_stack.resolve_runtime_data(updated_grp.t) # identify the template difference tmpl_diff = updated_grp.update_template_diff( updated_grp_json, current_grp_json) updated_policy = (updated_grp.t['UpdatePolicy'] if 'UpdatePolicy' in updated_grp.t else None) expected = {u'UpdatePolicy': updated_policy} self.assertEqual(expected, tmpl_diff) def test_update_policy_added(self): self.validate_update_policy_diff(ig_tmpl_without_updt_policy, ig_tmpl_with_updt_policy) def test_update_policy_updated(self): updt_template = json.loads(ig_tmpl_with_updt_policy) grp = updt_template['Resources']['JobServerGroup'] policy = grp['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '2' policy['MaxBatchSize'] = '4' policy['PauseTime'] = 'PT1M30S' self.validate_update_policy_diff(ig_tmpl_with_updt_policy, json.dumps(updt_template)) def test_update_policy_removed(self): self.validate_update_policy_diff(ig_tmpl_with_updt_policy, ig_tmpl_without_updt_policy) def update_instance_group(self, init_template, updt_template, num_updates_expected_on_updt, num_creates_expected_on_updt, num_deletes_expected_on_updt, update_replace): # setup stack from the initial template tmpl = template_format.parse(init_template) stack = utils.parse_stack(tmpl) stack.validate() # test stack create size = int(stack['JobServerGroup'].properties['Size']) self._stub_grp_create(size) self.m.ReplayAll() stack.create() self.m.VerifyAll() self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['JobServerGroup'] self.assertIn('RollingUpdate', current_grp.update_policy) current_policy = current_grp.update_policy['RollingUpdate'] self.assertTrue(current_policy) self.assertTrue(len(current_policy) > 0) init_grp_tmpl = tmpl['Resources']['JobServerGroup'] init_roll_updt = init_grp_tmpl['UpdatePolicy']['RollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['JobServerConfig'] conf_name_pattern = '%s-JobServerConfig-[a-zA-Z0-9]+$' % stack.name self.assertThat(conf.FnGetRefId(), MatchesRegex(conf_name_pattern)) # get launch conf name here to compare result after update conf_name = self.get_launch_conf_name(stack, 'JobServerGroup') # test the number of instances created nested = stack['JobServerGroup'].nested() self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() # saves info from initial list of instances for comparison later init_instances = current_grp.get_instances() init_names = current_grp.get_instance_names() init_images = [(i.name, i.t['Properties']['ImageId']) for i in init_instances] init_flavors = [(i.name, i.t['Properties']['InstanceType']) for i in init_instances] # test stack update updated_tmpl = template_format.parse(updt_template) updated_stack = utils.parse_stack(updated_tmpl) new_grp_tmpl = updated_tmpl['Resources']['JobServerGroup'] new_roll_updt = new_grp_tmpl['UpdatePolicy']['RollingUpdate'] new_batch_sz = int(new_roll_updt['MaxBatchSize']) self.assertNotEqual(new_batch_sz, init_batch_sz) if update_replace: self._stub_grp_replace(size, size) else: self._stub_grp_update(num_creates_expected_on_updt, num_deletes_expected_on_updt) self.stub_wallclock() self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that the update policy is updated updated_grp = stack['JobServerGroup'] self.assertIn('RollingUpdate', updated_grp.update_policy) updated_policy = updated_grp.update_policy['RollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) self.assertEqual(new_batch_sz, int(updated_policy['MaxBatchSize'])) # test that the launch configuration is replaced updated_conf_name = self.get_launch_conf_name(stack, 'JobServerGroup') self.assertNotEqual(conf_name, updated_conf_name) # test that the group size are the same updt_instances = updated_grp.get_instances() updt_names = updated_grp.get_instance_names() self.assertEqual(len(init_names), len(updt_names)) # test that the appropriate number of instance names are the same matched_names = set(updt_names) & set(init_names) self.assertEqual(num_updates_expected_on_updt, len(matched_names)) # test that the appropriate number of new instances are created self.assertEqual(num_creates_expected_on_updt, len(set(updt_names) - set(init_names))) # test that the appropriate number of instances are deleted self.assertEqual(num_deletes_expected_on_updt, len(set(init_names) - set(updt_names))) # test that the older instances are the ones being deleted if num_deletes_expected_on_updt > 0: deletes_expected = init_names[:num_deletes_expected_on_updt] self.assertNotIn(deletes_expected, updt_names) # test if instances are updated if update_replace: # test that the image id is changed for all instances updt_images = [(i.name, i.t['Properties']['ImageId']) for i in updt_instances] self.assertEqual(0, len(set(updt_images) & set(init_images))) else: # test that instance type is changed for all instances updt_flavors = [(i.name, i.t['Properties']['InstanceType']) for i in updt_instances] self.assertEqual(0, len(set(updt_flavors) & set(init_flavors))) def test_instance_group_update_replace(self): """ Test simple update replace with no conflict in batch size and minimum instances in service. """ updt_template = json.loads(ig_tmpl_with_updt_policy) grp = updt_template['Resources']['JobServerGroup'] policy = grp['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '1' policy['MaxBatchSize'] = '3' config = updt_template['Resources']['JobServerConfig'] config['Properties']['ImageId'] = 'bar' self.update_instance_group(ig_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=10, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, update_replace=True) def test_instance_group_update_replace_with_adjusted_capacity(self): """ Test update replace with capacity adjustment due to conflict in batch size and minimum instances in service. """ updt_template = json.loads(ig_tmpl_with_updt_policy) grp = updt_template['Resources']['JobServerGroup'] policy = grp['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '8' policy['MaxBatchSize'] = '4' config = updt_template['Resources']['JobServerConfig'] config['Properties']['ImageId'] = 'bar' self.update_instance_group(ig_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=8, num_creates_expected_on_updt=2, num_deletes_expected_on_updt=2, update_replace=True) def test_instance_group_update_replace_huge_batch_size(self): """ Test update replace with a huge batch size. """ updt_template = json.loads(ig_tmpl_with_updt_policy) group = updt_template['Resources']['JobServerGroup'] policy = group['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '0' policy['MaxBatchSize'] = '20' config = updt_template['Resources']['JobServerConfig'] config['Properties']['ImageId'] = 'bar' self.update_instance_group(ig_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=10, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, update_replace=True) def test_instance_group_update_replace_huge_min_in_service(self): """ Test update replace with a huge number of minimum instances in service. """ updt_template = json.loads(ig_tmpl_with_updt_policy) group = updt_template['Resources']['JobServerGroup'] policy = group['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '20' policy['MaxBatchSize'] = '1' policy['PauseTime'] = 'PT0S' config = updt_template['Resources']['JobServerConfig'] config['Properties']['ImageId'] = 'bar' self.update_instance_group(ig_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=9, num_creates_expected_on_updt=1, num_deletes_expected_on_updt=1, update_replace=True) def test_instance_group_update_no_replace(self): """ Test simple update only and no replace (i.e. updated instance flavor in Launch Configuration) with no conflict in batch size and minimum instances in service. """ updt_template = json.loads(copy.deepcopy(ig_tmpl_with_updt_policy)) group = updt_template['Resources']['JobServerGroup'] policy = group['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '1' policy['MaxBatchSize'] = '3' policy['PauseTime'] = 'PT0S' config = updt_template['Resources']['JobServerConfig'] config['Properties']['InstanceType'] = 'm1.large' self.update_instance_group(ig_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=10, num_creates_expected_on_updt=0, num_deletes_expected_on_updt=0, update_replace=False) def test_instance_group_update_no_replace_with_adjusted_capacity(self): """ Test update only and no replace (i.e. updated instance flavor in Launch Configuration) with capacity adjustment due to conflict in batch size and minimum instances in service. """ updt_template = json.loads(copy.deepcopy(ig_tmpl_with_updt_policy)) group = updt_template['Resources']['JobServerGroup'] policy = group['UpdatePolicy']['RollingUpdate'] policy['MinInstancesInService'] = '8' policy['MaxBatchSize'] = '4' policy['PauseTime'] = 'PT0S' config = updt_template['Resources']['JobServerConfig'] config['Properties']['InstanceType'] = 'm1.large' self.update_instance_group(ig_tmpl_with_updt_policy, json.dumps(updt_template), num_updates_expected_on_updt=8, num_creates_expected_on_updt=2, num_deletes_expected_on_updt=2, update_replace=False) def test_instance_group_update_policy_removed(self): # setup stack from the initial template tmpl = template_format.parse(ig_tmpl_with_updt_policy) stack = utils.parse_stack(tmpl) # test stack create size = int(stack['JobServerGroup'].properties['Size']) self._stub_grp_create(size) self.m.ReplayAll() stack.create() self.m.VerifyAll() self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['JobServerGroup'] self.assertIn('RollingUpdate', current_grp.update_policy) current_policy = current_grp.update_policy['RollingUpdate'] self.assertTrue(current_policy) self.assertTrue(len(current_policy) > 0) init_grp_tmpl = tmpl['Resources']['JobServerGroup'] init_roll_updt = init_grp_tmpl['UpdatePolicy']['RollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['JobServerConfig'] conf_name_pattern = '%s-JobServerConfig-[a-zA-Z0-9]+$' % stack.name self.assertThat(conf.FnGetRefId(), MatchesRegex(conf_name_pattern)) # test the number of instances created nested = stack['JobServerGroup'].nested() self.assertEqual(size, len(nested.resources)) # test stack update updated_tmpl = template_format.parse(ig_tmpl_without_updt_policy) updated_stack = utils.parse_stack(updated_tmpl) stack.update(updated_stack) self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that update policy is removed updated_grp = stack['JobServerGroup'] self.assertFalse(updated_grp.update_policy['RollingUpdate']) def test_instance_group_update_policy_check_timeout(self): # setup stack from the initial template tmpl = template_format.parse(ig_tmpl_with_updt_policy) stack = utils.parse_stack(tmpl) # test stack create size = int(stack['JobServerGroup'].properties['Size']) self._stub_grp_create(size) self.m.ReplayAll() stack.create() self.m.VerifyAll() self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['JobServerGroup'] self.assertIn('RollingUpdate', current_grp.update_policy) current_policy = current_grp.update_policy['RollingUpdate'] self.assertTrue(current_policy) self.assertTrue(len(current_policy) > 0) init_grp_tmpl = tmpl['Resources']['JobServerGroup'] init_roll_updt = init_grp_tmpl['UpdatePolicy']['RollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test the number of instances created nested = stack['JobServerGroup'].nested() self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() # modify the pause time and test for error new_pause_time = 'PT30M' updt_template = json.loads(copy.deepcopy(ig_tmpl_with_updt_policy)) group = updt_template['Resources']['JobServerGroup'] policy = group['UpdatePolicy']['RollingUpdate'] policy['PauseTime'] = new_pause_time config = updt_template['Resources']['JobServerConfig'] config['Properties']['ImageId'] = 'bar' updated_tmpl = template_format.parse(json.dumps(updt_template)) updated_stack = utils.parse_stack(updated_tmpl) stack.update(updated_stack) self.assertEqual(('UPDATE', 'FAILED'), stack.state) # test that the update policy is updated updated_grp = stack['JobServerGroup'] self.assertIn('RollingUpdate', updated_grp.update_policy) updated_policy = updated_grp.update_policy['RollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) self.assertEqual(new_pause_time, updated_policy['PauseTime']) # test that error message match expected_error_message = ('The current UpdatePolicy will result ' 'in stack update timeout.') self.assertIn(expected_error_message, stack.status_reason) heat-2014.1.5/heat/tests/test_security_group.py0000664000567000056700000010217712540642614022620 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. import collections from neutronclient.common.exceptions import NeutronClientException from neutronclient.v2_0 import client as neutronclient from novaclient.v1_1 import security_group_rules as nova_sgr from novaclient.v1_1 import security_groups as nova_sg from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests.fakes import FakeKeystoneClient from heat.tests import utils from heat.tests.v1_1 import fakes NovaSG = collections.namedtuple('NovaSG', ' '.join([ 'name', 'id', 'rules', 'description', ])) class SecurityGroupTest(HeatTestCase): test_template_nova = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: HTTP and SSH access SecurityGroupIngress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 0.0.0.0/0 - IpProtocol: tcp FromPort : "80" ToPort : "80" CidrIp : 0.0.0.0/0 - IpProtocol: tcp SourceSecurityGroupName: test - IpProtocol: icmp SourceSecurityGroupId: "1" ''' test_template_nova_bad_source_group = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: HTTP and SSH access SecurityGroupIngress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 0.0.0.0/0 - IpProtocol: tcp FromPort : "80" ToPort : "80" CidrIp : 0.0.0.0/0 - IpProtocol: tcp SourceSecurityGroupName: thisdoesnotexist - IpProtocol: icmp SourceSecurityGroupId: "1" ''' test_template_nova_with_egress = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: HTTP and SSH access SecurityGroupEgress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 0.0.0.0/0 ''' test_template_neutron = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: HTTP and SSH access VpcId: aaaa SecurityGroupIngress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 0.0.0.0/0 - IpProtocol: tcp FromPort : "80" ToPort : "80" CidrIp : 0.0.0.0/0 - IpProtocol: tcp SourceSecurityGroupId: wwww SecurityGroupEgress: - IpProtocol: tcp FromPort: "22" ToPort: "22" CidrIp: 10.0.1.0/24 - SourceSecurityGroupName: xxxx ''' def setUp(self): super(SecurityGroupTest, self).setUp() self.fc = fakes.FakeClient() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') self.m.StubOutWithMock(nova_sgr.SecurityGroupRuleManager, 'create') self.m.StubOutWithMock(nova_sgr.SecurityGroupRuleManager, 'delete') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'create') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'delete') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'get') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'list') utils.setup_dummy_db() self.m.StubOutWithMock(neutronclient.Client, 'create_security_group') self.m.StubOutWithMock( neutronclient.Client, 'create_security_group_rule') self.m.StubOutWithMock(neutronclient.Client, 'show_security_group') self.m.StubOutWithMock( neutronclient.Client, 'delete_security_group_rule') self.m.StubOutWithMock(neutronclient.Client, 'delete_security_group') def create_stack(self, template): t = template_format.parse(template) self.stack = self.parse_stack(t) self.assertIsNone(self.stack.create()) return self.stack def parse_stack(self, t): stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, tmpl) stack.store() return stack def assertResourceState(self, rsrc, ref_id, metadata={}): self.assertIsNone(rsrc.validate()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual(ref_id, rsrc.FnGetRefId()) self.assertEqual(metadata, dict(rsrc.metadata)) @utils.stack_delete_after def test_security_group_nova(self): #create script clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.list().AndReturn([NovaSG( id=1, name='test', description='FAKE_SECURITY_GROUP', rules=[], )]) clients.OpenStackClients.nova('compute').AndReturn(self.fc) sg_name = utils.PhysName('test_stack', 'the_sg') nova_sg.SecurityGroupManager.create( sg_name, 'HTTP and SSH access').AndReturn(NovaSG( id=2, name=sg_name, description='HTTP and SSH access', rules=[])) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', '22', '22', '0.0.0.0/0', None).AndReturn(None) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', '80', '80', '0.0.0.0/0', None).AndReturn(None) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', None, None, None, 1).AndReturn(None) nova_sgr.SecurityGroupRuleManager.create( 2, 'icmp', None, None, None, '1').AndReturn(None) # delete script clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.get(2).AndReturn(NovaSG( id=2, name=sg_name, description='HTTP and SSH access', rules=[{ "from_port": '22', "group": {}, "ip_protocol": "tcp", "to_port": '22', "parent_group_id": 2, "ip_range": { "cidr": "0.0.0.0/0" }, 'id': 130 }, { 'from_port': '80', 'group': {}, 'ip_protocol': 'tcp', 'to_port': '80', 'parent_group_id': 2, 'ip_range': { 'cidr': '0.0.0.0/0' }, 'id': 131 }, { 'from_port': None, 'group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'test' }, 'ip_protocol': 'tcp', 'to_port': None, 'parent_group_id': 2, 'ip_range': {}, 'id': 132 }, { 'from_port': None, 'group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'test' }, 'ip_protocol': 'icmp', 'to_port': None, 'parent_group_id': 2, 'ip_range': {}, 'id': 133 }] )) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(130).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(131).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(132).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(133).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.delete(2).AndReturn(None) self.m.ReplayAll() stack = self.create_stack(self.test_template_nova) sg = stack['the_sg'] self.assertRaises(resource.UpdateReplace, sg.handle_update, {}, {}, {}) self.assertResourceState(sg, utils.PhysName('test_stack', 'the_sg')) stack.delete() self.m.VerifyAll() @utils.stack_delete_after def test_security_group_nova_bad_source_group(self): #create script clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.list().AndReturn([NovaSG( id=1, name='test', description='FAKE_SECURITY_GROUP', rules=[], )]) clients.OpenStackClients.nova('compute').AndReturn(self.fc) sg_name = utils.PhysName('test_stack', 'the_sg') nova_sg.SecurityGroupManager.create( sg_name, 'HTTP and SSH access').AndReturn(NovaSG( id=2, name=sg_name, description='HTTP and SSH access', rules=[])) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', '22', '22', '0.0.0.0/0', None).AndReturn(None) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', '80', '80', '0.0.0.0/0', None).AndReturn(None) # delete script clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.get(2).AndReturn(NovaSG( id=2, name=sg_name, description='HTTP and SSH access', rules=[{ "from_port": '22', "group": {}, "ip_protocol": "tcp", "to_port": '22', "parent_group_id": 2, "ip_range": { "cidr": "0.0.0.0/0" }, 'id': 130 }, { 'from_port': '80', 'group': {}, 'ip_protocol': 'tcp', 'to_port': '80', 'parent_group_id': 2, 'ip_range': { 'cidr': '0.0.0.0/0' }, 'id': 131 }] )) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(130).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(131).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.delete(2).AndReturn(None) self.m.ReplayAll() stack = self.create_stack(self.test_template_nova_bad_source_group) sg = stack['the_sg'] self.assertEqual(sg.FAILED, sg.status) self.assertIn('not found', sg.status_reason) stack.delete() self.m.VerifyAll() @utils.stack_delete_after def test_security_group_nova_exception(self): #create script clients.OpenStackClients.nova('compute').AndReturn(self.fc) sg_name = utils.PhysName('test_stack', 'the_sg') nova_sg.SecurityGroupManager.list().AndReturn([ NovaSG( id=2, name=sg_name, description='HTTP and SSH access', rules=[], ), NovaSG( id=1, name='test', description='FAKE_SECURITY_GROUP', rules=[], ) ]) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', '22', '22', '0.0.0.0/0', None).AndRaise( fakes.fake_exception(400, 'Rule already exists')) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', '80', '80', '0.0.0.0/0', None).AndReturn( fakes.fake_exception(400, 'Rule already exists')) nova_sgr.SecurityGroupRuleManager.create( 2, 'tcp', None, None, None, 1).AndReturn( fakes.fake_exception(400, 'Rule already exists')) nova_sgr.SecurityGroupRuleManager.create( 2, 'icmp', None, None, None, '1').AndReturn( fakes.fake_exception(400, 'Rule already exists')) # delete script clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.get(2).AndReturn(NovaSG( id=2, name=sg_name, description='HTTP and SSH access', rules=[{ "from_port": '22', "group": {}, "ip_protocol": "tcp", "to_port": '22', "parent_group_id": 2, "ip_range": { "cidr": "0.0.0.0/0" }, 'id': 130 }, { 'from_port': '80', 'group': {}, 'ip_protocol': 'tcp', 'to_port': '80', 'parent_group_id': 2, 'ip_range': { 'cidr': '0.0.0.0/0' }, 'id': 131 }, { 'from_port': None, 'group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'test' }, 'ip_protocol': 'tcp', 'to_port': None, 'parent_group_id': 2, 'ip_range': {}, 'id': 132 }, { 'from_port': None, 'group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'test' }, 'ip_protocol': 'icmp', 'to_port': None, 'parent_group_id': 2, 'ip_range': {}, 'id': 133 }] )) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(130).AndRaise( clients.novaclient.exceptions.NotFound('goneburger')) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(131).AndRaise( clients.novaclient.exceptions.NotFound('goneburger')) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(132).AndRaise( clients.novaclient.exceptions.NotFound('goneburger')) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sgr.SecurityGroupRuleManager.delete(133).AndRaise( clients.novaclient.exceptions.NotFound('goneburger')) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.delete(2).AndReturn(None) clients.OpenStackClients.nova('compute').AndReturn(self.fc) nova_sg.SecurityGroupManager.get(2).AndRaise( clients.novaclient.exceptions.NotFound('goneburger')) self.m.ReplayAll() stack = self.create_stack(self.test_template_nova) sg = stack['the_sg'] self.assertRaises(resource.UpdateReplace, sg.handle_update, {}, {}, {}) self.assertResourceState(sg, utils.PhysName('test_stack', 'the_sg')) scheduler.TaskRunner(sg.delete)() sg.state_set(sg.CREATE, sg.COMPLETE, 'to delete again') sg.resource_id = 2 stack.delete() self.m.VerifyAll() def test_security_group_nova_with_egress_rules(self): t = template_format.parse(self.test_template_nova_with_egress) stack = self.parse_stack(t) sg = stack['the_sg'] self.assertRaises(exception.EgressRuleNotAllowed, sg.validate) @utils.stack_delete_after def test_security_group_neutron(self): #create script clients.OpenStackClients.keystone().AndReturn( FakeKeystoneClient()) sg_name = utils.PhysName('test_stack', 'the_sg') neutronclient.Client.create_security_group({ 'security_group': { 'name': sg_name, 'description': 'HTTP and SSH access' } }).AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': sg_name, 'description': 'HTTP and SSH access', 'security_group_rules': [{ "direction": "egress", "ethertype": "IPv4", "id": "aaaa-1", "port_range_max": None, "port_range_min": None, "protocol": None, "remote_group_id": None, "remote_ip_prefix": None, "security_group_id": "aaaa", "tenant_id": "f18ca530cc05425e8bac0a5ff92f7e88" }, { "direction": "egress", "ethertype": "IPv6", "id": "aaaa-2", "port_range_max": None, "port_range_min": None, "protocol": None, "remote_group_id": None, "remote_ip_prefix": None, "security_group_id": "aaaa", "tenant_id": "f18ca530cc05425e8bac0a5ff92f7e88" }], 'id': 'aaaa' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'bbbb' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '80', 'ethertype': 'IPv4', 'port_range_max': '80', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '80', 'ethertype': 'IPv4', 'port_range_max': '80', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'cccc' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'dddd' } }) neutronclient.Client.delete_security_group_rule('aaaa-1').AndReturn( None) neutronclient.Client.delete_security_group_rule('aaaa-2').AndReturn( None) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'eeee' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa', 'id': 'ffff' } }) # delete script neutronclient.Client.show_security_group('aaaa').AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'sc1', 'description': '', 'security_group_rules': [{ 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'bbbb', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '80', 'id': 'cccc', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '80' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': None, 'id': 'dddd', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }, { 'direction': 'egress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'eeee', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'egress', 'protocol': None, 'port_range_max': None, 'id': 'ffff', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }], 'id': 'aaaa'}}) neutronclient.Client.delete_security_group_rule('bbbb').AndReturn(None) neutronclient.Client.delete_security_group_rule('cccc').AndReturn(None) neutronclient.Client.delete_security_group_rule('dddd').AndReturn(None) neutronclient.Client.delete_security_group_rule('eeee').AndReturn(None) neutronclient.Client.delete_security_group_rule('ffff').AndReturn(None) neutronclient.Client.delete_security_group('aaaa').AndReturn(None) self.m.ReplayAll() stack = self.create_stack(self.test_template_neutron) sg = stack['the_sg'] self.assertRaises(resource.UpdateReplace, sg.handle_update, {}, {}, {}) self.assertResourceState(sg, 'aaaa') stack.delete() self.m.VerifyAll() @utils.stack_delete_after def test_security_group_neutron_exception(self): #create script clients.OpenStackClients.keystone().AndReturn( FakeKeystoneClient()) sg_name = utils.PhysName('test_stack', 'the_sg') neutronclient.Client.create_security_group({ 'security_group': { 'name': sg_name, 'description': 'HTTP and SSH access' } }).AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': sg_name, 'description': 'HTTP and SSH access', 'security_group_rules': [], 'id': 'aaaa' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '80', 'ethertype': 'IPv4', 'port_range_max': '80', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) # delete script neutronclient.Client.show_security_group('aaaa').AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'sc1', 'description': '', 'security_group_rules': [{ 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'bbbb', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '80', 'id': 'cccc', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '80' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': None, 'id': 'dddd', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }, { 'direction': 'egress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'eeee', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'egress', 'protocol': None, 'port_range_max': None, 'id': 'ffff', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }], 'id': 'aaaa'}}) neutronclient.Client.delete_security_group_rule('bbbb').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('cccc').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('dddd').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('eeee').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('ffff').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group('aaaa').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.show_security_group('aaaa').AndRaise( NeutronClientException(status_code=404)) self.m.ReplayAll() stack = self.create_stack(self.test_template_neutron) sg = stack['the_sg'] self.assertRaises(resource.UpdateReplace, sg.handle_update, {}, {}, {}) self.assertResourceState(sg, 'aaaa') scheduler.TaskRunner(sg.delete)() sg.state_set(sg.CREATE, sg.COMPLETE, 'to delete again') sg.resource_id = 'aaaa' stack.delete() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_environment_format.py0000664000567000056700000000475112540642614023450 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. import mock import yaml from heat.common import environment_format from heat.tests import common class YamlEnvironmentTest(common.HeatTestCase): def test_minimal_yaml(self): yaml1 = '' yaml2 = ''' parameters: {} resource_registry: {} ''' tpl1 = environment_format.parse(yaml1) environment_format.default_for_missing(tpl1) tpl2 = environment_format.parse(yaml2) self.assertEqual(tpl1, tpl2) def test_wrong_sections(self): env = ''' parameters: {} resource_regis: {} ''' self.assertRaises(ValueError, environment_format.parse, env) def test_bad_yaml(self): env = ''' parameters: } ''' self.assertRaises(ValueError, environment_format.parse, env) def test_yaml_none(self): self.assertEqual({}, environment_format.parse(None)) def test_parse_string_environment(self): env = 'just string' expect = 'The environment is not a valid YAML mapping data type.' msg = self.assertRaises(ValueError, environment_format.parse, env) self.assertIn(expect, msg) def test_parse_document(self): env = '["foo" , "bar"]' expect = 'The environment is not a valid YAML mapping data type.' msg = self.assertRaises(ValueError, environment_format.parse, env) self.assertIn(expect, msg) class YamlParseExceptions(common.HeatTestCase): scenarios = [ ('scanner', dict(raised_exception=yaml.scanner.ScannerError())), ('parser', dict(raised_exception=yaml.parser.ParserError())), ('reader', dict(raised_exception=yaml.reader.ReaderError('', '', '', '', ''))), ] def test_parse_to_value_exception(self): text = 'not important' with mock.patch.object(yaml, 'load') as yaml_loader: yaml_loader.side_effect = self.raised_exception self.assertRaises(ValueError, environment_format.parse, text) heat-2014.1.5/heat/tests/test_support.py0000664000567000056700000000343412540642614021245 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. from heat.engine import support from heat.tests.common import HeatTestCase class SupportStatusTest(HeatTestCase): def test_valid_status(self): status = support.SupportStatus( status=support.DEPRECATED, message='test_message', version='test_version' ) self.assertEqual('DEPRECATED', status.status) self.assertEqual('test_message', status.message) self.assertEqual('test_version', status.version) self.assertEqual({ 'status': 'DEPRECATED', 'message': 'test_message', 'version': 'test_version' }, status.to_dict()) def test_invalid_status(self): status = support.SupportStatus( status='RANDOM', message='test_message', version='test_version' ) self.assertEqual(support.UNKNOWN, status.status) self.assertEqual('Specified status is invalid, defaulting to UNKNOWN', status.message) self.assertIsNone(status.version) self.assertEqual({ 'status': 'UNKNOWN', 'message': 'Specified status is invalid, defaulting to UNKNOWN', 'version': None }, status.to_dict()) heat-2014.1.5/heat/tests/test_identifier.py0000664000567000056700000004320512540642614021653 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. import testtools from heat.common import identifier class IdentifierTest(testtools.TestCase): url_prefix = 'http://1.2.3.4/foo/' def test_attrs(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('/p', hi.path) def test_path_default(self): hi = identifier.HeatIdentifier('t', 's', 'i') self.assertEqual('', hi.path) def test_items(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertEqual('t', hi['tenant']) self.assertEqual('s', hi['stack_name']) self.assertEqual('i', hi['stack_id']) self.assertEqual('/p', hi['path']) def test_invalid_attr(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') hi.identity['foo'] = 'bar' self.assertRaises(AttributeError, getattr, hi, 'foo') def test_invalid_item(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') hi.identity['foo'] = 'bar' self.assertRaises(KeyError, lambda o, k: o[k], hi, 'foo') def test_stack_path(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertEqual('s/i', hi.stack_path()) def test_arn(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertEqual('arn:openstack:heat::t:stacks/s/i/p', hi.arn()) def test_arn_url(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertEqual('/arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2Fp', hi.arn_url_path()) def test_arn_id_int(self): hi = identifier.HeatIdentifier('t', 's', 42, 'p') self.assertEqual('arn:openstack:heat::t:stacks/s/42/p', hi.arn()) def test_arn_parse(self): arn = 'arn:openstack:heat::t:stacks/s/i/p' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('/p', hi.path) def test_arn_url_parse(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i/p' hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('/p', hi.path) def test_arn_parse_path_default(self): arn = 'arn:openstack:heat::t:stacks/s/i' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('', hi.path) def test_arn_url_parse_default(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i' hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('', hi.path) def test_arn_parse_upper(self): arn = 'ARN:openstack:heat::t:stacks/s/i/p' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('/p', hi.path) def test_arn_url_parse_upper(self): url = self.url_prefix + 'ARN%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i/p' hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('/p', hi.path) def test_arn_url_parse_qs(self): url = self.url_prefix +\ 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i/p?foo=bar' hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual('t', hi.tenant) self.assertEqual('s', hi.stack_name) self.assertEqual('i', hi.stack_id) self.assertEqual('/p', hi.path) def test_arn_parse_arn_invalid(self): arn = 'urn:openstack:heat::t:stacks/s/i' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn, arn) def test_arn_url_parse_arn_invalid(self): url = self.url_prefix + 'urn:openstack:heat::t:stacks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_parse_os_invalid(self): arn = 'arn:aws:heat::t:stacks/s/i' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn, arn) def test_arn_url_parse_os_invalid(self): url = self.url_prefix + 'arn:aws:heat::t:stacks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_parse_heat_invalid(self): arn = 'arn:openstack:cool::t:stacks/s/i' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn, arn) def test_arn_url_parse_heat_invalid(self): url = self.url_prefix + 'arn:openstack:cool::t:stacks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_parse_stacks_invalid(self): arn = 'arn:openstack:heat::t:sticks/s/i' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn, arn) def test_arn_url_parse_stacks_invalid(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Asticks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_parse_missing_field(self): arn = 'arn:openstack:heat::t:stacks/s' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn, arn) def test_arn_url_parse_missing_field(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Asticks/s/' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_parse_empty_field(self): arn = 'arn:openstack:heat::t:stacks//i' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn, arn) def test_arn_url_parse_empty_field(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Asticks//i' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_url_parse_leading_char(self): url = self.url_prefix + 'Aarn%3Aopenstack%3Aheat%3A%3At%3Asticks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_url_parse_leading_space(self): url = self.url_prefix + ' arn%3Aopenstack%3Aheat%3A%3At%3Asticks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_url_parse_badurl_proto(self): url = 'htt://1.2.3.4/foo/arn%3Aopenstack%3Aheat%3A%3At%3Asticks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_url_parse_badurl_host(self): url = 'http:///foo/arn%3Aopenstack%3Aheat%3A%3At%3Asticks/s/i/p' self.assertRaises(ValueError, identifier.HeatIdentifier.from_arn_url, url) def test_arn_round_trip(self): hii = identifier.HeatIdentifier('t', 's', 'i', 'p') hio = identifier.HeatIdentifier.from_arn(hii.arn()) self.assertEqual(hii.tenant, hio.tenant) self.assertEqual(hii.stack_name, hio.stack_name) self.assertEqual(hii.stack_id, hio.stack_id) self.assertEqual(hii.path, hio.path) def test_arn_parse_round_trip(self): arn = 'arn:openstack:heat::t:stacks/s/i/p' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual(arn, hi.arn()) def test_arn_url_parse_round_trip(self): arn = '/arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2Fp' url = 'http://1.2.3.4/foo' + arn hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual(arn, hi.arn_url_path()) def test_dict_round_trip(self): hii = identifier.HeatIdentifier('t', 's', 'i', 'p') hio = identifier.HeatIdentifier(**dict(hii)) self.assertEqual(hii.tenant, hio.tenant) self.assertEqual(hii.stack_name, hio.stack_name) self.assertEqual(hii.stack_id, hio.stack_id) self.assertEqual(hii.path, hio.path) def test_url_path(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertEqual('t/stacks/s/i/p', hi.url_path()) def test_url_path_default(self): hi = identifier.HeatIdentifier('t', 's', 'i') self.assertEqual('t/stacks/s/i', hi.url_path()) def test_url_path_with_unicode_path(self): hi = identifier.HeatIdentifier('t', 's', 'i', u'\u5de5') self.assertEqual('t/stacks/s/i/%E5%B7%A5', hi.url_path()) def test_tenant_escape(self): hi = identifier.HeatIdentifier(':/', 's', 'i') self.assertEqual(':/', hi.tenant) self.assertEqual('%3A%2F/stacks/s/i', hi.url_path()) self.assertEqual('arn:openstack:heat::%3A%2F:stacks/s/i', hi.arn()) def test_name_escape(self): hi = identifier.HeatIdentifier('t', ':%', 'i') self.assertEqual(':%', hi.stack_name) self.assertEqual('t/stacks/%3A%25/i', hi.url_path()) self.assertEqual('arn:openstack:heat::t:stacks/%3A%25/i', hi.arn()) def test_id_escape(self): hi = identifier.HeatIdentifier('t', 's', ':/') self.assertEqual(':/', hi.stack_id) self.assertEqual('t/stacks/s/%3A%2F', hi.url_path()) self.assertEqual('arn:openstack:heat::t:stacks/s/%3A%2F', hi.arn()) def test_path_escape(self): hi = identifier.HeatIdentifier('t', 's', 'i', ':/') self.assertEqual('/:/', hi.path) self.assertEqual('t/stacks/s/i/%3A/', hi.url_path()) self.assertEqual('arn:openstack:heat::t:stacks/s/i/%3A/', hi.arn()) def test_tenant_decode(self): arn = 'arn:openstack:heat::%3A%2F:stacks/s/i' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual(':/', hi.tenant) def test_url_tenant_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3A%253A%252F%3Astacks%2Fs%2Fi' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual(':/', hi.tenant) def test_name_decode(self): arn = 'arn:openstack:heat::t:stacks/%3A%25/i' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual(':%', hi.stack_name) def test_url_name_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2F%253A%2525%2Fi' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual(':%', hi.stack_name) def test_id_decode(self): arn = 'arn:openstack:heat::t:stacks/s/%3A%2F' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual(':/', hi.stack_id) def test_url_id_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2F%253A%252F' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual(':/', hi.stack_id) def test_path_decode(self): arn = 'arn:openstack:heat::t:stacks/s/i/%3A%2F' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual('/:/', hi.path) def test_url_path_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2F%253A%252F' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) self.assertEqual('/:/', hi.path) def test_arn_escape_decode_round_trip(self): hii = identifier.HeatIdentifier(':/', ':%', ':/', ':/') hio = identifier.HeatIdentifier.from_arn(hii.arn()) self.assertEqual(hii.tenant, hio.tenant) self.assertEqual(hii.stack_name, hio.stack_name) self.assertEqual(hii.stack_id, hio.stack_id) self.assertEqual(hii.path, hio.path) def test_arn_decode_escape_round_trip(self): arn = 'arn:openstack:heat::%3A%2F:stacks/%3A%25/%3A%2F/%3A/' hi = identifier.HeatIdentifier.from_arn(arn) self.assertEqual(arn, hi.arn()) def test_arn_url_decode_escape_round_trip(self): enc_arn = "".join(['arn%3Aopenstack%3Aheat%3A%3A%253A%252F%3A', 'stacks%2F%253A%2525%2F%253A%252F%2F%253A']) url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) hi2 = identifier.HeatIdentifier.from_arn_url(self.url_prefix + hi.arn_url_path()) self.assertEqual(hi, hi2) def test_stack_name_slash(self): self.assertRaises(ValueError, identifier.HeatIdentifier, 't', 's/s', 'i', 'p') def test_equal(self): hi1 = identifier.HeatIdentifier('t', 's', 'i', 'p') hi2 = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertTrue(hi1 == hi2) def test_equal_dict(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') self.assertTrue(hi == dict(hi)) self.assertTrue(dict(hi) == hi) def test_not_equal(self): hi1 = identifier.HeatIdentifier('t', 's', 'i', 'p') hi2 = identifier.HeatIdentifier('t', 's', 'i', 'q') self.assertFalse(hi1 == hi2) self.assertFalse(hi2 == hi1) def test_not_equal_dict(self): hi1 = identifier.HeatIdentifier('t', 's', 'i', 'p') hi2 = identifier.HeatIdentifier('t', 's', 'i', 'q') self.assertFalse(hi1 == dict(hi2)) self.assertFalse(dict(hi1) == hi2) self.assertFalse(hi1 == {'tenant': 't', 'stack_name': 's', 'stack_id': 'i'}) self.assertFalse({'tenant': 't', 'stack_name': 's', 'stack_id': 'i'} == hi1) def test_path_components(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p1/p2/p3') self.assertEqual(['p1', 'p2', 'p3'], hi._path_components()) class ResourceIdentifierTest(testtools.TestCase): def test_resource_init_no_path(self): si = identifier.HeatIdentifier('t', 's', 'i') ri = identifier.ResourceIdentifier(resource_name='r', **si) self.assertEqual('/resources/r', ri.path) def test_resource_init_path(self): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='p', **si) ri = identifier.ResourceIdentifier(resource_name='r', **pi) self.assertEqual('/resources/p/resources/r', ri.path) def test_resource_init_from_dict(self): hi = identifier.HeatIdentifier('t', 's', 'i', '/resources/r') ri = identifier.ResourceIdentifier(**hi) self.assertEqual(hi, ri) def test_resource_stack(self): si = identifier.HeatIdentifier('t', 's', 'i') ri = identifier.ResourceIdentifier(resource_name='r', **si) self.assertEqual(si, ri.stack()) def test_resource_id(self): ri = identifier.ResourceIdentifier('t', 's', 'i', '', 'r') self.assertEqual('r', ri.resource_name) def test_resource_name_slash(self): self.assertRaises(ValueError, identifier.ResourceIdentifier, 't', 's', 'i', 'p', 'r/r') class EventIdentifierTest(testtools.TestCase): def test_event_init_integer_id(self): self._test_event_init('42') def test_event_init_uuid_id(self): self._test_event_init('a3455d8c-9f88-404d-a85b-5315293e67de') def _test_event_init(self, event_id): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='p', **si) ei = identifier.EventIdentifier(event_id=event_id, **pi) self.assertEqual('/resources/p/events/{0}'.format(event_id), ei.path) def test_event_init_from_dict(self): hi = identifier.HeatIdentifier('t', 's', 'i', '/resources/p/events/42') ei = identifier.EventIdentifier(**hi) self.assertEqual(hi, ei) def test_event_stack(self): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='r', **si) ei = identifier.EventIdentifier(event_id='e', **pi) self.assertEqual(si, ei.stack()) def test_event_resource(self): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='r', **si) ei = identifier.EventIdentifier(event_id='e', **pi) self.assertEqual(pi, ei.resource()) def test_resource_name(self): ei = identifier.EventIdentifier('t', 's', 'i', '/resources/p', 'e') self.assertEqual('p', ei.resource_name) def test_event_id_integer(self): self._test_event_id('42') def test_event_id_uuid(self): self._test_event_id('a3455d8c-9f88-404d-a85b-5315293e67de') def _test_event_id(self, event_id): ei = identifier.EventIdentifier('t', 's', 'i', '/resources/p', event_id) self.assertEqual(event_id, ei.event_id) heat-2014.1.5/heat/tests/test_sqlalchemy_api.py0000664000567000056700000017477712540642614022547 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. from datetime import datetime from datetime import timedelta import uuid import fixtures from json import dumps from json import loads import mock import mox from heat.common import context from heat.common import exception from heat.common import template_format from heat.db.sqlalchemy import api as db_api from heat.engine import clients from heat.engine.clients import novaclient from heat.engine import environment from heat.engine import parser from heat.engine.resource import Resource from heat.engine.resources import instance as instances from heat.engine import scheduler from heat.openstack.common import timeutils from heat.tests.common import HeatTestCase from heat.tests import utils from heat.tests.v1_1 import fakes wp_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "WordPress", "Parameters" : { "KeyName" : { "Description" : "KeyName", "Type" : "String", "Default" : "test" } }, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "wordpress" } } } } ''' UUIDs = (UUID1, UUID2, UUID3) = sorted([str(uuid.uuid4()) for x in range(3)]) class MyResource(Resource): properties_schema = { 'ServerName': {'Type': 'String', 'Required': True}, 'Flavor': {'Type': 'String', 'Required': True}, 'ImageName': {'Type': 'String', 'Required': True}, 'UserData': {'Type': 'String'}, 'PublicKey': {'Type': 'String'} } @property def my_secret(self): return db_api.resource_data_get(self, 'my_secret') @my_secret.setter def my_secret(self, my_secret): db_api.resource_data_set(self, 'my_secret', my_secret, True) class SqlAlchemyTest(HeatTestCase): def setUp(self): super(SqlAlchemyTest, self).setUp() self.fc = fakes.FakeClient() utils.setup_dummy_db() utils.reset_dummy_db() self.ctx = utils.dummy_context() def tearDown(self): super(SqlAlchemyTest, self).tearDown() def _setup_test_stack(self, stack_name, stack_id=None, owner_id=None, stack_user_project_id=None): t = template_format.parse(wp_template) template = parser.Template(t) stack_id = stack_id or str(uuid.uuid4()) stack = parser.Stack(self.ctx, stack_name, template, environment.Environment({'KeyName': 'test'}), owner_id=owner_id, stack_user_project_id=stack_user_project_id) with utils.UUIDStub(stack_id): stack.store() return (t, stack) def _mock_create(self, mocks): fc = fakes.FakeClient() mocks.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) mocks.StubOutWithMock(fc.servers, 'create') fc.servers.create(image=744, flavor=3, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=None, nics=None, availability_zone=None).MultipleTimes().AndReturn( fc.servers.list()[4]) return fc def _mock_delete(self, mocks): fc = fakes.FakeClient() mocks.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) mocks.StubOutWithMock(fc.client, 'get_servers_9999') get = fc.client.get_servers_9999 get().MultipleTimes().AndRaise(novaclient.exceptions.NotFound(404)) @mock.patch.object(db_api, '_paginate_query') def test_filter_and_page_query_paginates_query(self, mock_paginate_query): query = mock.Mock() db_api._filter_and_page_query(self.ctx, query) assert mock_paginate_query.called @mock.patch.object(db_api.db_filters, 'exact_filter') def test_filter_and_page_query_handles_no_filters(self, mock_db_filter): query = mock.Mock() db_api._filter_and_page_query(self.ctx, query) mock_db_filter.assert_called_once_with(mock.ANY, mock.ANY, {}) @mock.patch.object(db_api.db_filters, 'exact_filter') def test_filter_and_page_query_applies_filters(self, mock_db_filter): query = mock.Mock() filters = {'foo': 'bar'} db_api._filter_and_page_query(self.ctx, query, filters=filters) assert mock_db_filter.called @mock.patch.object(db_api, '_paginate_query') def test_filter_and_page_query_whitelists_sort_keys(self, mock_paginate_query): query = mock.Mock() sort_keys = ['name', 'foo'] db_api._filter_and_page_query(self.ctx, query, sort_keys=sort_keys) args, _ = mock_paginate_query.call_args self.assertIn(['name'], args) @mock.patch.object(db_api.utils, 'paginate_query') def test_paginate_query_default_sorts_by_created_at_and_id( self, mock_paginate_query): query = mock.Mock() model = mock.Mock() db_api._paginate_query(self.ctx, query, model, sort_keys=None) args, _ = mock_paginate_query.call_args self.assertIn(['created_at', 'id'], args) @mock.patch.object(db_api.utils, 'paginate_query') def test_paginate_query_default_sorts_dir_by_desc(self, mock_paginate_query): query = mock.Mock() model = mock.Mock() db_api._paginate_query(self.ctx, query, model, sort_dir=None) args, _ = mock_paginate_query.call_args self.assertIn('desc', args) @mock.patch.object(db_api.utils, 'paginate_query') def test_paginate_query_uses_given_sort_plus_id(self, mock_paginate_query): query = mock.Mock() model = mock.Mock() db_api._paginate_query(self.ctx, query, model, sort_keys=['name']) args, _ = mock_paginate_query.call_args self.assertIn(['name', 'id'], args) @mock.patch.object(db_api.utils, 'paginate_query') @mock.patch.object(db_api, 'model_query') def test_paginate_query_gets_model_marker(self, mock_query, mock_paginate_query): query = mock.Mock() model = mock.Mock() marker = mock.Mock() mock_query_object = mock.Mock() mock_query_object.get.return_value = 'real_marker' mock_query.return_value = mock_query_object db_api._paginate_query(self.ctx, query, model, marker=marker) mock_query_object.get.assert_called_once_with(marker) args, _ = mock_paginate_query.call_args self.assertIn('real_marker', args) @mock.patch.object(db_api.utils, 'paginate_query') def test_paginate_query_raises_invalid_sort_key(self, mock_paginate_query): query = mock.Mock() model = mock.Mock() mock_paginate_query.side_effect = db_api.utils.InvalidSortKey() self.assertRaises(exception.Invalid, db_api._paginate_query, self.ctx, query, model, sort_keys=['foo']) def test_filter_sort_keys_returns_empty_list_if_no_keys(self): sort_keys = None whitelist = None filtered_keys = db_api._filter_sort_keys(sort_keys, whitelist) self.assertEqual([], filtered_keys) def test_filter_sort_keys_whitelists_single_key(self): sort_key = 'foo' whitelist = ['foo'] filtered_keys = db_api._filter_sort_keys(sort_key, whitelist) self.assertEqual(['foo'], filtered_keys) def test_filter_sort_keys_whitelists_multiple_keys(self): sort_keys = ['foo', 'bar', 'nope'] whitelist = ['foo', 'bar'] filtered_keys = db_api._filter_sort_keys(sort_keys, whitelist) self.assertIn('foo', filtered_keys) self.assertIn('bar', filtered_keys) self.assertNotIn('nope', filtered_keys) def test_encryption(self): stack_name = 'test_encryption' (t, stack) = self._setup_test_stack(stack_name) cs = MyResource('cs_encryption', t['Resources']['WebServer'], stack) # This gives the fake cloud server an id and created_time attribute cs._store_or_update(cs.CREATE, cs.IN_PROGRESS, 'test_store') cs.my_secret = 'fake secret' rs = db_api.resource_get_by_name_and_stack(self.ctx, 'cs_encryption', stack.id) encrypted_key = rs.data[0]['value'] self.assertNotEqual(encrypted_key, "fake secret") # Test private_key property returns decrypted value self.assertEqual("fake secret", cs.my_secret) #do this twice to verify that the orm does not commit the unencrypted #value. self.assertEqual("fake secret", cs.my_secret) scheduler.TaskRunner(cs.destroy)() def test_resource_data_delete(self): stack = self._setup_test_stack('stack', UUID1)[1] self._mock_create(self.m) self.m.ReplayAll() stack.create() rsrc = stack['WebServer'] db_api.resource_data_set(rsrc, 'test', 'test_data') self.assertEqual('test_data', db_api.resource_data_get(rsrc, 'test')) db_api.resource_data_delete(rsrc, 'test') self.assertRaises(exception.NotFound, db_api.resource_data_get, rsrc, 'test') def test_stack_get_by_name(self): stack = self._setup_test_stack('stack', UUID1, stack_user_project_id=UUID2)[1] st = db_api.stack_get_by_name(self.ctx, 'stack') self.assertEqual(UUID1, st.id) self.ctx.tenant_id = UUID3 st = db_api.stack_get_by_name(self.ctx, 'stack') self.assertIsNone(st) self.ctx.tenant_id = UUID2 st = db_api.stack_get_by_name(self.ctx, 'stack') self.assertEqual(UUID1, st.id) stack.delete() st = db_api.stack_get_by_name(self.ctx, 'stack') self.assertIsNone(st) def test_nested_stack_get_by_name(self): stack1 = self._setup_test_stack('stack1', UUID1)[1] stack2 = self._setup_test_stack('stack2', UUID2, owner_id=stack1.id)[1] result = db_api.stack_get_by_name(self.ctx, 'stack2') self.assertEqual(UUID2, result.id) stack2.delete() result = db_api.stack_get_by_name(self.ctx, 'stack2') self.assertIsNone(result) def test_stack_get_by_name_and_owner_id(self): stack1 = self._setup_test_stack('stack1', UUID1, stack_user_project_id=UUID3)[1] stack2 = self._setup_test_stack('stack2', UUID2, owner_id=stack1.id, stack_user_project_id=UUID3)[1] result = db_api.stack_get_by_name_and_owner_id(self.ctx, 'stack2', None) self.assertIsNone(result) result = db_api.stack_get_by_name_and_owner_id(self.ctx, 'stack2', stack1.id) self.assertEqual(UUID2, result.id) self.ctx.tenant_id = str(uuid.uuid4()) result = db_api.stack_get_by_name_and_owner_id(self.ctx, 'stack2', None) self.assertIsNone(result) self.ctx.tenant_id = UUID3 result = db_api.stack_get_by_name_and_owner_id(self.ctx, 'stack2', stack1.id) self.assertEqual(UUID2, result.id) stack2.delete() result = db_api.stack_get_by_name_and_owner_id(self.ctx, 'stack2', stack1.id) self.assertIsNone(result) def test_stack_get(self): stack = self._setup_test_stack('stack', UUID1)[1] st = db_api.stack_get(self.ctx, UUID1, show_deleted=False) self.assertEqual(UUID1, st.id) stack.delete() st = db_api.stack_get(self.ctx, UUID1, show_deleted=False) self.assertIsNone(st) st = db_api.stack_get(self.ctx, UUID1, show_deleted=True) self.assertEqual(UUID1, st.id) def test_stack_get_show_deleted_context(self): stack = self._setup_test_stack('stack', UUID1)[1] self.assertFalse(self.ctx.show_deleted) st = db_api.stack_get(self.ctx, UUID1) self.assertEqual(UUID1, st.id) stack.delete() st = db_api.stack_get(self.ctx, UUID1) self.assertIsNone(st) self.ctx.show_deleted = True st = db_api.stack_get(self.ctx, UUID1) self.assertEqual(UUID1, st.id) def test_stack_get_all(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] st_db = db_api.stack_get_all(self.ctx) self.assertEqual(3, len(st_db)) stacks[0].delete() st_db = db_api.stack_get_all(self.ctx) self.assertEqual(2, len(st_db)) stacks[1].delete() st_db = db_api.stack_get_all(self.ctx) self.assertEqual(1, len(st_db)) def test_stack_get_all_with_filters(self): self._setup_test_stack('foo', UUID1) self._setup_test_stack('bar', UUID2) filters = {'name': 'foo'} results = db_api.stack_get_all(self.ctx, filters=filters) self.assertEqual(1, len(results)) self.assertEqual('foo', results[0]['name']) def test_stack_get_all_filter_matches_in_list(self): self._setup_test_stack('foo', UUID1) self._setup_test_stack('bar', UUID2) filters = {'name': ['bar', 'quux']} results = db_api.stack_get_all(self.ctx, filters=filters) self.assertEqual(1, len(results)) self.assertEqual('bar', results[0]['name']) def test_stack_get_all_returns_all_if_no_filters(self): self._setup_test_stack('foo', UUID1) self._setup_test_stack('bar', UUID2) filters = None results = db_api.stack_get_all(self.ctx, filters=filters) self.assertEqual(2, len(results)) def test_stack_get_all_default_sort_keys_and_dir(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] st_db = db_api.stack_get_all(self.ctx) self.assertEqual(3, len(st_db)) self.assertEqual(stacks[2].id, st_db[0].id) self.assertEqual(stacks[1].id, st_db[1].id) self.assertEqual(stacks[0].id, st_db[2].id) def test_stack_get_all_default_sort_dir(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] st_db = db_api.stack_get_all(self.ctx, sort_dir='asc') self.assertEqual(3, len(st_db)) self.assertEqual(stacks[0].id, st_db[0].id) self.assertEqual(stacks[1].id, st_db[1].id) self.assertEqual(stacks[2].id, st_db[2].id) def test_stack_get_all_str_sort_keys(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] st_db = db_api.stack_get_all(self.ctx, sort_keys='created_at') self.assertEqual(3, len(st_db)) self.assertEqual(stacks[0].id, st_db[0].id) self.assertEqual(stacks[1].id, st_db[1].id) self.assertEqual(stacks[2].id, st_db[2].id) @mock.patch.object(db_api.utils, 'paginate_query') def test_stack_get_all_filters_sort_keys(self, mock_paginate): sort_keys = ['name', 'status', 'created_at', 'updated_at', 'username'] db_api.stack_get_all(self.ctx, sort_keys=sort_keys) args = mock_paginate.call_args[0] used_sort_keys = set(args[3]) expected_keys = set(['name', 'status', 'created_at', 'updated_at', 'id']) self.assertEqual(expected_keys, used_sort_keys) def test_stack_get_all_marker(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] st_db = db_api.stack_get_all(self.ctx, marker=stacks[1].id) self.assertEqual(1, len(st_db)) self.assertEqual(stacks[0].id, st_db[0].id) def test_stack_get_all_non_existing_marker(self): [self._setup_test_stack('stack', x)[1] for x in UUIDs] uuid = 'this stack doesnt exist' st_db = db_api.stack_get_all(self.ctx, marker=uuid) self.assertEqual(3, len(st_db)) def test_stack_get_all_doesnt_mutate_sort_keys(self): [self._setup_test_stack('stack', x)[1] for x in UUIDs] sort_keys = ['id'] db_api.stack_get_all(self.ctx, sort_keys=sort_keys) self.assertEqual(['id'], sort_keys) def test_stack_count_all(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] st_db = db_api.stack_count_all(self.ctx) self.assertEqual(3, st_db) stacks[0].delete() st_db = db_api.stack_count_all(self.ctx) self.assertEqual(2, st_db) stacks[1].delete() st_db = db_api.stack_count_all(self.ctx) self.assertEqual(1, st_db) def test_stack_count_all_with_filters(self): self._setup_test_stack('foo', UUID1) self._setup_test_stack('bar', UUID2) self._setup_test_stack('bar', UUID3) filters = {'name': 'bar'} st_db = db_api.stack_count_all(self.ctx, filters=filters) self.assertEqual(2, st_db) def test_event_get_all_by_stack(self): stack = self._setup_test_stack('stack', UUID1)[1] self._mock_create(self.m) self.m.ReplayAll() stack.create() self.m.UnsetStubs() events = db_api.event_get_all_by_stack(self.ctx, UUID1) self.assertEqual(2, len(events)) self._mock_delete(self.m) self.m.ReplayAll() stack.delete() events = db_api.event_get_all_by_stack(self.ctx, UUID1) self.assertEqual(4, len(events)) self.m.VerifyAll() def test_event_count_all_by_stack(self): stack = self._setup_test_stack('stack', UUID1)[1] self._mock_create(self.m) self.m.ReplayAll() stack.create() self.m.UnsetStubs() num_events = db_api.event_count_all_by_stack(self.ctx, UUID1) self.assertEqual(2, num_events) self._mock_delete(self.m) self.m.ReplayAll() stack.delete() num_events = db_api.event_count_all_by_stack(self.ctx, UUID1) self.assertEqual(4, num_events) self.m.VerifyAll() def test_event_get_all_by_tenant(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] self._mock_create(self.m) self.m.ReplayAll() [s.create() for s in stacks] self.m.UnsetStubs() events = db_api.event_get_all_by_tenant(self.ctx) self.assertEqual(6, len(events)) self._mock_delete(self.m) self.m.ReplayAll() [s.delete() for s in stacks] events = db_api.event_get_all_by_tenant(self.ctx) self.assertEqual(0, len(events)) self.m.VerifyAll() def test_event_get_all(self): stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs] self._mock_create(self.m) self.m.ReplayAll() [s.create() for s in stacks] self.m.UnsetStubs() events = db_api.event_get_all(self.ctx) self.assertEqual(6, len(events)) self._mock_delete(self.m) self.m.ReplayAll() stacks[0].delete() events = db_api.event_get_all(self.ctx) self.assertEqual(4, len(events)) self.m.VerifyAll() def test_user_creds_password(self): self.ctx.trust_id = None db_creds = db_api.user_creds_create(self.ctx) load_creds = db_api.user_creds_get(db_creds.id) self.assertEqual('test_username', load_creds.get('username')) self.assertEqual('password', load_creds.get('password')) self.assertEqual('test_tenant', load_creds.get('tenant')) self.assertEqual('test_tenant_id', load_creds.get('tenant_id')) self.assertIsNotNone(load_creds.get('created_at')) self.assertIsNone(load_creds.get('updated_at')) self.assertEqual('http://server.test:5000/v2.0', load_creds.get('auth_url')) self.assertIsNone(load_creds.get('trust_id')) self.assertIsNone(load_creds.get('trustor_user_id')) def test_user_creds_trust(self): self.ctx.username = None self.ctx.password = None self.ctx.trust_id = 'atrust123' self.ctx.trustor_user_id = 'atrustor123' self.ctx.tenant_id = 'atenant123' self.ctx.tenant = 'atenant' db_creds = db_api.user_creds_create(self.ctx) load_creds = db_api.user_creds_get(db_creds.id) self.assertIsNone(load_creds.get('username')) self.assertIsNone(load_creds.get('password')) self.assertIsNotNone(load_creds.get('created_at')) self.assertIsNone(load_creds.get('updated_at')) self.assertIsNone(load_creds.get('auth_url')) self.assertEqual('atenant123', load_creds.get('tenant_id')) self.assertEqual('atenant', load_creds.get('tenant')) self.assertEqual('atrust123', load_creds.get('trust_id')) self.assertEqual('atrustor123', load_creds.get('trustor_user_id')) def test_user_creds_none(self): self.ctx.username = None self.ctx.password = None self.ctx.trust_id = None db_creds = db_api.user_creds_create(self.ctx) load_creds = db_api.user_creds_get(db_creds.id) self.assertIsNone(load_creds.get('username')) self.assertIsNone(load_creds.get('password')) self.assertIsNone(load_creds.get('trust_id')) def test_software_config_create(self): tenant_id = self.ctx.tenant_id config = db_api.software_config_create( self.ctx, {'name': 'config_mysql', 'tenant': tenant_id}) self.assertIsNotNone(config) self.assertEqual('config_mysql', config.name) self.assertEqual(tenant_id, config.tenant) def test_software_config_get(self): self.assertRaises( exception.NotFound, db_api.software_config_get, self.ctx, str(uuid.uuid4())) conf = ('#!/bin/bash\n' 'echo "$bar and $foo"\n') config = { 'inputs': [{'name': 'foo'}, {'name': 'bar'}], 'outputs': [{'name': 'result'}], 'config': conf, 'options': {} } tenant_id = self.ctx.tenant_id values = {'name': 'config_mysql', 'tenant': tenant_id, 'group': 'Heat::Shell', 'config': config} config = db_api.software_config_create( self.ctx, values) config_id = config.id config = db_api.software_config_get(self.ctx, config_id) self.assertIsNotNone(config) self.assertEqual('config_mysql', config.name) self.assertEqual(tenant_id, config.tenant) self.assertEqual('Heat::Shell', config.group) self.assertEqual(conf, config.config['config']) self.ctx.tenant_id = None self.assertRaises( exception.NotFound, db_api.software_config_get, self.ctx, config_id) def test_software_config_delete(self): tenant_id = self.ctx.tenant_id config = db_api.software_config_create( self.ctx, {'name': 'config_mysql', 'tenant': tenant_id}) config_id = config.id db_api.software_config_delete(self.ctx, config_id) err = self.assertRaises( exception.NotFound, db_api.software_config_get, self.ctx, config_id) self.assertIn(config_id, str(err)) err = self.assertRaises( exception.NotFound, db_api.software_config_delete, self.ctx, config_id) self.assertIn(config_id, str(err)) def _deployment_values(self): tenant_id = self.ctx.tenant_id stack_user_project_id = str(uuid.uuid4()) config_id = db_api.software_config_create( self.ctx, {'name': 'config_mysql', 'tenant': tenant_id}).id server_id = str(uuid.uuid4()) input_values = {'foo': 'fooooo', 'bar': 'baaaaa'} values = { 'tenant': tenant_id, 'stack_user_project_id': stack_user_project_id, 'config_id': config_id, 'server_id': server_id, 'input_values': input_values } return values def test_software_deployment_create(self): values = self._deployment_values() deployment = db_api.software_deployment_create(self.ctx, values) self.assertIsNotNone(deployment) self.assertEqual(values['tenant'], deployment.tenant) def test_software_deployment_get(self): self.assertRaises( exception.NotFound, db_api.software_deployment_get, self.ctx, str(uuid.uuid4())) values = self._deployment_values() deployment = db_api.software_deployment_create(self.ctx, values) self.assertIsNotNone(deployment) deployment_id = deployment.id deployment = db_api.software_deployment_get(self.ctx, deployment_id) self.assertIsNotNone(deployment) self.assertEqual(values['tenant'], deployment.tenant) self.assertEqual(values['config_id'], deployment.config_id) self.assertEqual(values['server_id'], deployment.server_id) self.assertEqual(values['input_values'], deployment.input_values) self.assertEqual( values['stack_user_project_id'], deployment.stack_user_project_id) # assert not found with invalid context tenant self.ctx.tenant_id = str(uuid.uuid4()) self.assertRaises( exception.NotFound, db_api.software_deployment_get, self.ctx, deployment_id) # assert found with stack_user_project_id context tenant self.ctx.tenant_id = deployment.stack_user_project_id deployment = db_api.software_deployment_get(self.ctx, deployment_id) self.assertIsNotNone(deployment) self.assertEqual(values['tenant'], deployment.tenant) def test_software_deployment_get_all(self): self.assertEqual([], db_api.software_deployment_get_all(self.ctx)) values = self._deployment_values() deployment = db_api.software_deployment_create(self.ctx, values) self.assertIsNotNone(deployment) all = db_api.software_deployment_get_all(self.ctx) self.assertEqual(1, len(all)) self.assertEqual(deployment, all[0]) all = db_api.software_deployment_get_all( self.ctx, server_id=values['server_id']) self.assertEqual(1, len(all)) self.assertEqual(deployment, all[0]) all = db_api.software_deployment_get_all( self.ctx, server_id=str(uuid.uuid4())) self.assertEqual([], all) def test_software_deployment_update(self): deployment_id = str(uuid.uuid4()) err = self.assertRaises(exception.NotFound, db_api.software_deployment_update, self.ctx, deployment_id, values={}) self.assertIn(deployment_id, str(err)) values = self._deployment_values() deployment = db_api.software_deployment_create(self.ctx, values) deployment_id = deployment.id values = {'status': 'COMPLETED'} deployment = db_api.software_deployment_update( self.ctx, deployment_id, values) self.assertIsNotNone(deployment) self.assertEqual(values['status'], deployment.status) def test_software_deployment_delete(self): deployment_id = str(uuid.uuid4()) err = self.assertRaises(exception.NotFound, db_api.software_deployment_delete, self.ctx, deployment_id) self.assertIn(deployment_id, str(err)) values = self._deployment_values() deployment = db_api.software_deployment_create(self.ctx, values) deployment_id = deployment.id deployment = db_api.software_deployment_get(self.ctx, deployment_id) self.assertIsNotNone(deployment) db_api.software_deployment_delete(self.ctx, deployment_id) err = self.assertRaises( exception.NotFound, db_api.software_deployment_get, self.ctx, deployment_id) self.assertIn(deployment_id, str(err)) def create_raw_template(context, **kwargs): t = template_format.parse(wp_template) template = { 'template': t, 'files': {'foo': 'bar'} } template.update(kwargs) return db_api.raw_template_create(context, template) def create_user_creds(ctx, **kwargs): ctx_dict = ctx.to_dict() ctx_dict.update(kwargs) ctx = context.RequestContext.from_dict(ctx_dict) return db_api.user_creds_create(ctx) def create_stack(ctx, template, user_creds, **kwargs): values = { 'name': 'db_test_stack_name', 'raw_template_id': template.id, 'username': ctx.username, 'tenant': ctx.tenant_id, 'action': 'create', 'status': 'complete', 'status_reason': 'create_complete', 'parameters': {}, 'user_creds_id': user_creds.id, 'owner_id': None, 'timeout': '60', 'disable_rollback': 0 } values.update(kwargs) return db_api.stack_create(ctx, values) def create_resource(ctx, stack, **kwargs): values = { 'name': 'test_resource_name', 'nova_instance': UUID1, 'action': 'create', 'status': 'complete', 'status_reason': 'create_complete', 'rsrc_metadata': loads('{"foo": "123"}'), 'stack_id': stack.id } values.update(kwargs) return db_api.resource_create(ctx, values) def create_resource_data(ctx, resource, **kwargs): values = { 'key': 'test_resource_key', 'value': 'test_value', 'redact': 0, } values.update(kwargs) return db_api.resource_data_set(resource, **values) def create_event(ctx, **kwargs): values = { 'stack_id': 'test_stack_id', 'resource_action': 'create', 'resource_status': 'complete', 'resource_name': 'res', 'physical_resource_id': UUID1, 'resource_status_reason': "create_complete", 'resource_properties': {'name': 'foo'} } values.update(kwargs) return db_api.event_create(ctx, values) def create_watch_rule(ctx, stack, **kwargs): values = { 'name': 'test_rule', 'rule': loads('{"foo": "123"}'), 'state': 'normal', 'last_evaluated': timeutils.utcnow(), 'stack_id': stack.id, } values.update(kwargs) return db_api.watch_rule_create(ctx, values) def create_watch_data(ctx, watch_rule, **kwargs): values = { 'data': loads('{"foo": "bar"}'), 'watch_rule_id': watch_rule.id } values.update(kwargs) return db_api.watch_data_create(ctx, values) class DBAPIRawTemplateTest(HeatTestCase): def setUp(self): super(DBAPIRawTemplateTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() def test_raw_template_create(self): t = template_format.parse(wp_template) tp = create_raw_template(self.ctx, template=t) self.assertIsNotNone(tp.id) self.assertEqual(t, tp.template) self.assertEqual({'foo': 'bar'}, tp.files) def test_raw_template_get(self): t = template_format.parse(wp_template) tp = create_raw_template(self.ctx, template=t) template = db_api.raw_template_get(self.ctx, tp.id) self.assertEqual(tp.id, template.id) self.assertEqual(tp.template, template.template) class DBAPIUserCredsTest(HeatTestCase): def setUp(self): super(DBAPIUserCredsTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() def test_user_creds_create_trust(self): user_creds = create_user_creds(self.ctx, trust_id='test_trust_id', trustor_user_id='trustor_id') self.assertIsNotNone(user_creds.id) self.assertEqual('test_trust_id', db_api._decrypt(user_creds.trust_id, user_creds.decrypt_method)) self.assertEqual('trustor_id', user_creds.trustor_user_id) self.assertIsNone(user_creds.username) self.assertIsNone(user_creds.password) self.assertEqual(self.ctx.tenant, user_creds.tenant) self.assertEqual(self.ctx.tenant_id, user_creds.tenant_id) def test_user_creds_create_password(self): user_creds = create_user_creds(self.ctx) self.assertIsNotNone(user_creds.id) self.assertEqual(self.ctx.password, db_api._decrypt(user_creds.password, user_creds.decrypt_method)) def test_user_creds_get(self): user_creds = create_user_creds(self.ctx) ret_user_creds = db_api.user_creds_get(user_creds.id) self.assertEqual(db_api._decrypt(user_creds.password, user_creds.decrypt_method), ret_user_creds['password']) def test_user_creds_get_noexist(self): self.assertIsNone(db_api.user_creds_get(123456)) def test_user_creds_delete(self): user_creds = create_user_creds(self.ctx) self.assertIsNotNone(user_creds.id) db_api.user_creds_delete(self.ctx, user_creds.id) creds = db_api.user_creds_get(user_creds.id) self.assertIsNone(creds) err = self.assertRaises( exception.NotFound, db_api.user_creds_delete, self.ctx, user_creds.id) exp_msg = ('Attempt to delete user creds with id ' '%s that does not exist' % user_creds.id) self.assertIn(exp_msg, str(err)) class DBAPIStackTest(HeatTestCase): def setUp(self): super(DBAPIStackTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) def test_stack_create(self): stack = create_stack(self.ctx, self.template, self.user_creds) self.assertIsNotNone(stack.id) self.assertEqual('db_test_stack_name', stack.name) self.assertEqual(self.template.id, stack.raw_template_id) self.assertEqual(self.ctx.username, stack.username) self.assertEqual(self.ctx.tenant_id, stack.tenant) self.assertEqual('create', stack.action) self.assertEqual('complete', stack.status) self.assertEqual('create_complete', stack.status_reason) self.assertEqual({}, stack.parameters) self.assertEqual(self.user_creds.id, stack.user_creds_id) self.assertIsNone(stack.owner_id) self.assertEqual('60', stack.timeout) self.assertFalse(stack.disable_rollback) def test_stack_delete(self): stack = create_stack(self.ctx, self.template, self.user_creds) stack_id = stack.id resource = create_resource(self.ctx, stack) db_api.stack_delete(self.ctx, stack_id) self.assertIsNone(db_api.stack_get(self.ctx, stack_id, show_deleted=False)) self.assertRaises(exception.NotFound, db_api.resource_get, self.ctx, resource.id) self.assertRaises(exception.NotFound, db_api.stack_delete, self.ctx, stack_id) #Testing soft delete ret_stack = db_api.stack_get(self.ctx, stack_id, show_deleted=True) self.assertIsNotNone(ret_stack) self.assertEqual(stack_id, ret_stack.id) self.assertEqual('db_test_stack_name', ret_stack.name) #Testing child resources deletion self.assertRaises(exception.NotFound, db_api.resource_get, self.ctx, resource.id) def test_stack_update(self): stack = create_stack(self.ctx, self.template, self.user_creds) values = { 'name': 'db_test_stack_name2', 'action': 'update', 'status': 'failed', 'status_reason': "update_failed", 'timeout': '90', } db_api.stack_update(self.ctx, stack.id, values) stack = db_api.stack_get(self.ctx, stack.id) self.assertEqual('db_test_stack_name2', stack.name) self.assertEqual('update', stack.action) self.assertEqual('failed', stack.status) self.assertEqual('update_failed', stack.status_reason) self.assertEqual('90', stack.timeout) self.assertRaises(exception.NotFound, db_api.stack_update, self.ctx, UUID2, values) def test_stack_get_returns_a_stack(self): stack = create_stack(self.ctx, self.template, self.user_creds) ret_stack = db_api.stack_get(self.ctx, stack.id, show_deleted=False) self.assertIsNotNone(ret_stack) self.assertEqual(stack.id, ret_stack.id) self.assertEqual('db_test_stack_name', ret_stack.name) def test_stack_get_returns_none_if_stack_does_not_exist(self): stack = db_api.stack_get(self.ctx, UUID1, show_deleted=False) self.assertIsNone(stack) def test_stack_get_returns_none_if_tenant_id_does_not_match(self): stack = create_stack(self.ctx, self.template, self.user_creds) self.ctx.tenant_id = 'abc' stack = db_api.stack_get(self.ctx, UUID1, show_deleted=False) self.assertIsNone(stack) def test_stack_get_tenant_is_stack_user_project_id(self): stack = create_stack(self.ctx, self.template, self.user_creds, stack_user_project_id='astackuserproject') self.ctx.tenant_id = 'astackuserproject' ret_stack = db_api.stack_get(self.ctx, stack.id, show_deleted=False) self.assertIsNotNone(ret_stack) self.assertEqual(stack.id, ret_stack.id) self.assertEqual('db_test_stack_name', ret_stack.name) def test_stack_get_can_return_a_stack_from_different_tenant(self): stack = create_stack(self.ctx, self.template, self.user_creds) self.ctx.tenant_id = 'abc' ret_stack = db_api.stack_get(self.ctx, stack.id, show_deleted=False, tenant_safe=False) self.assertEqual(stack.id, ret_stack.id) self.assertEqual('db_test_stack_name', ret_stack.name) def test_stack_get_by_name(self): stack = create_stack(self.ctx, self.template, self.user_creds) ret_stack = db_api.stack_get_by_name(self.ctx, stack.name) self.assertIsNotNone(ret_stack) self.assertEqual(stack.id, ret_stack.id) self.assertEqual('db_test_stack_name', ret_stack.name) self.assertIsNone(db_api.stack_get_by_name(self.ctx, 'abc')) self.ctx.tenant_id = 'abc' self.assertIsNone(db_api.stack_get_by_name(self.ctx, 'abc')) def test_stack_get_all(self): values = [ {'name': 'stack1'}, {'name': 'stack2'}, {'name': 'stack3'}, {'name': 'stack4'} ] [create_stack(self.ctx, self.template, self.user_creds, **val) for val in values] ret_stacks = db_api.stack_get_all(self.ctx) self.assertEqual(4, len(ret_stacks)) names = [ret_stack.name for ret_stack in ret_stacks] [self.assertIn(val['name'], names) for val in values] def test_stack_get_all_by_owner_id(self): parent_stack1 = create_stack(self.ctx, self.template, self.user_creds) parent_stack2 = create_stack(self.ctx, self.template, self.user_creds) values = [ {'owner_id': parent_stack1.id}, {'owner_id': parent_stack1.id}, {'owner_id': parent_stack2.id}, {'owner_id': parent_stack2.id}, ] [create_stack(self.ctx, self.template, self.user_creds, **val) for val in values] stack1_children = db_api.stack_get_all_by_owner_id(self.ctx, parent_stack1.id) self.assertEqual(2, len(stack1_children)) stack2_children = db_api.stack_get_all_by_owner_id(self.ctx, parent_stack2.id) self.assertEqual(2, len(stack2_children)) def test_stack_get_all_with_regular_tenant(self): values = [ {'tenant': UUID1}, {'tenant': UUID1}, {'tenant': UUID2}, {'tenant': UUID2}, {'tenant': UUID2}, ] [create_stack(self.ctx, self.template, self.user_creds, **val) for val in values] self.ctx.tenant_id = UUID1 stacks = db_api.stack_get_all(self.ctx) self.assertEqual(2, len(stacks)) self.ctx.tenant_id = UUID2 stacks = db_api.stack_get_all(self.ctx) self.assertEqual(3, len(stacks)) self.ctx.tenant_id = UUID3 self.assertEqual([], db_api.stack_get_all(self.ctx)) def test_stack_get_all_with_tenant_safe_false(self): values = [ {'tenant': UUID1}, {'tenant': UUID1}, {'tenant': UUID2}, {'tenant': UUID2}, {'tenant': UUID2}, ] [create_stack(self.ctx, self.template, self.user_creds, **val) for val in values] stacks = db_api.stack_get_all(self.ctx, tenant_safe=False) self.assertEqual(5, len(stacks)) def test_stack_count_all_with_regular_tenant(self): values = [ {'tenant': UUID1}, {'tenant': UUID1}, {'tenant': UUID2}, {'tenant': UUID2}, {'tenant': UUID2}, ] [create_stack(self.ctx, self.template, self.user_creds, **val) for val in values] self.ctx.tenant_id = UUID1 self.assertEqual(2, db_api.stack_count_all(self.ctx)) self.ctx.tenant_id = UUID2 self.assertEqual(3, db_api.stack_count_all(self.ctx)) def test_stack_count_all_with_tenant_safe_false(self): values = [ {'tenant': UUID1}, {'tenant': UUID1}, {'tenant': UUID2}, {'tenant': UUID2}, {'tenant': UUID2}, ] [create_stack(self.ctx, self.template, self.user_creds, **val) for val in values] self.assertEqual(5, db_api.stack_count_all(self.ctx, tenant_safe=False)) def test_purge_deleted(self): now = datetime.now() delta = timedelta(seconds=3600 * 7) deleted = [now - delta * i for i in range(1, 6)] templates = [create_raw_template(self.ctx) for i in range(5)] creds = [create_user_creds(self.ctx) for i in range(5)] stacks = [create_stack(self.ctx, templates[i], creds[i], deleted_at=deleted[i]) for i in range(5)] class MyDatetime(): def now(self): return now self.useFixture(fixtures.MonkeyPatch('heat.db.sqlalchemy.api.datetime', MyDatetime())) db_api.purge_deleted(age=1, granularity='days') self._deleted_stack_existance(utils.dummy_context(), stacks, (0, 1, 2), (3, 4)) db_api.purge_deleted(age=22, granularity='hours') self._deleted_stack_existance(utils.dummy_context(), stacks, (0, 1, 2), (3, 4)) db_api.purge_deleted(age=1100, granularity='minutes') self._deleted_stack_existance(utils.dummy_context(), stacks, (0, 1), (2, 3, 4)) db_api.purge_deleted(age=3600, granularity='seconds') self._deleted_stack_existance(utils.dummy_context(), stacks, (), (0, 1, 2, 3, 4)) def _deleted_stack_existance(self, ctx, stacks, existing, deleted): for s in existing: self.assertIsNotNone(db_api.stack_get(ctx, stacks[s].id, show_deleted=True)) for s in deleted: self.assertIsNone(db_api.stack_get(ctx, stacks[s].id, show_deleted=True)) def test_stack_status_reason_truncate(self): stack = create_stack(self.ctx, self.template, self.user_creds, status_reason='a' * 1024) self.assertEqual('a' * 255, stack.status_reason) class DBAPIResourceTest(HeatTestCase): def setUp(self): super(DBAPIResourceTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) self.stack = create_stack(self.ctx, self.template, self.user_creds) def test_resource_create(self): res = create_resource(self.ctx, self.stack) ret_res = db_api.resource_get(self.ctx, res.id) self.assertIsNotNone(ret_res) self.assertEqual('test_resource_name', ret_res.name) self.assertEqual(UUID1, ret_res.nova_instance) self.assertEqual('create', ret_res.action) self.assertEqual('complete', ret_res.status) self.assertEqual('create_complete', ret_res.status_reason) self.assertEqual('{"foo": "123"}', dumps(ret_res.rsrc_metadata)) self.assertEqual(self.stack.id, ret_res.stack_id) def test_resource_get(self): res = create_resource(self.ctx, self.stack) ret_res = db_api.resource_get(self.ctx, res.id) self.assertIsNotNone(ret_res) self.assertRaises(exception.NotFound, db_api.resource_get, self.ctx, UUID2) def test_resource_get_by_name_and_stack(self): create_resource(self.ctx, self.stack) ret_res = db_api.resource_get_by_name_and_stack(self.ctx, 'test_resource_name', self.stack.id) self.assertIsNotNone(ret_res) self.assertEqual('test_resource_name', ret_res.name) self.assertEqual(self.stack.id, ret_res.stack_id) self.assertIsNone(db_api.resource_get_by_name_and_stack(self.ctx, 'abc', self.stack.id)) def test_resource_get_by_physical_resource_id(self): create_resource(self.ctx, self.stack) ret_res = db_api.resource_get_by_physical_resource_id(self.ctx, UUID1) self.assertIsNotNone(ret_res) self.assertEqual(UUID1, ret_res.nova_instance) self.assertIsNone(db_api.resource_get_by_physical_resource_id(self.ctx, UUID2)) def test_resource_get_all(self): values = [ {'name': 'res1'}, {'name': 'res2'}, {'name': 'res3'}, ] [create_resource(self.ctx, self.stack, **val) for val in values] resources = db_api.resource_get_all(self.ctx) self.assertEqual(3, len(resources)) names = [resource.name for resource in resources] [self.assertIn(val['name'], names) for val in values] def test_resource_get_all_by_stack(self): self.stack1 = create_stack(self.ctx, self.template, self.user_creds) self.stack2 = create_stack(self.ctx, self.template, self.user_creds) values = [ {'name': 'res1', 'stack_id': self.stack.id}, {'name': 'res2', 'stack_id': self.stack.id}, {'name': 'res3', 'stack_id': self.stack1.id}, ] [create_resource(self.ctx, self.stack, **val) for val in values] stacks = db_api.resource_get_all_by_stack(self.ctx, self.stack.id) self.assertEqual(2, len(stacks)) self.assertRaises(exception.NotFound, db_api.resource_get_all_by_stack, self.ctx, self.stack2.id) def test_resource_status_reason_truncate(self): res = create_resource(self.ctx, self.stack, status_reason='a' * 1024) ret_res = db_api.resource_get(self.ctx, res.id) self.assertEqual('a' * 255, ret_res.status_reason) class DBAPIStackLockTest(HeatTestCase): def setUp(self): super(DBAPIStackLockTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) self.stack = create_stack(self.ctx, self.template, self.user_creds) def test_stack_lock_create_success(self): observed = db_api.stack_lock_create(self.stack.id, UUID1) self.assertIsNone(observed) def test_stack_lock_create_fail_double_same(self): db_api.stack_lock_create(self.stack.id, UUID1) observed = db_api.stack_lock_create(self.stack.id, UUID1) self.assertEqual(UUID1, observed) def test_stack_lock_create_fail_double_different(self): db_api.stack_lock_create(self.stack.id, UUID1) observed = db_api.stack_lock_create(self.stack.id, UUID2) self.assertEqual(UUID1, observed) def test_stack_lock_steal_success(self): db_api.stack_lock_create(self.stack.id, UUID1) observed = db_api.stack_lock_steal(self.stack.id, UUID1, UUID2) self.assertIsNone(observed) def test_stack_lock_steal_fail_gone(self): db_api.stack_lock_create(self.stack.id, UUID1) db_api.stack_lock_release(self.stack.id, UUID1) observed = db_api.stack_lock_steal(self.stack.id, UUID1, UUID2) self.assertTrue(observed) def test_stack_lock_steal_fail_stolen(self): db_api.stack_lock_create(self.stack.id, UUID1) # Simulate stolen lock db_api.stack_lock_release(self.stack.id, UUID1) db_api.stack_lock_create(self.stack.id, UUID2) observed = db_api.stack_lock_steal(self.stack.id, UUID3, UUID2) self.assertEqual(UUID2, observed) def test_stack_lock_release_success(self): db_api.stack_lock_create(self.stack.id, UUID1) observed = db_api.stack_lock_release(self.stack.id, UUID1) self.assertIsNone(observed) def test_stack_lock_release_fail_double(self): db_api.stack_lock_create(self.stack.id, UUID1) db_api.stack_lock_release(self.stack.id, UUID1) observed = db_api.stack_lock_release(self.stack.id, UUID1) self.assertTrue(observed) def test_stack_lock_release_fail_wrong_engine_id(self): db_api.stack_lock_create(self.stack.id, UUID1) observed = db_api.stack_lock_release(self.stack.id, UUID2) self.assertTrue(observed) class DBAPIResourceDataTest(HeatTestCase): def setUp(self): super(DBAPIResourceDataTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) self.stack = create_stack(self.ctx, self.template, self.user_creds) self.resource = create_resource(self.ctx, self.stack) self.resource.context = self.ctx def test_resource_data_set_get(self): create_resource_data(self.ctx, self.resource) val = db_api.resource_data_get(self.resource, 'test_resource_key') self.assertEqual('test_value', val) #Updating existing resource data create_resource_data(self.ctx, self.resource, value='foo') val = db_api.resource_data_get(self.resource, 'test_resource_key') self.assertEqual('foo', val) #Testing with encrypted value create_resource_data(self.ctx, self.resource, key='encryped_resource_key', redact=True) val = db_api.resource_data_get(self.resource, 'encryped_resource_key') self.assertEqual('test_value', val) vals = db_api.resource_data_get_all(self.resource) self.assertEqual(2, len(vals)) self.assertEqual('foo', vals.get('test_resource_key')) self.assertEqual('test_value', vals.get('encryped_resource_key')) def test_resource_data_delete(self): create_resource_data(self.ctx, self.resource) res_data = db_api.resource_data_get_by_key(self.ctx, self.resource.id, 'test_resource_key') self.assertIsNotNone(res_data) self.assertEqual('test_value', res_data.value) db_api.resource_data_delete(self.resource, 'test_resource_key') self.assertRaises(exception.NotFound, db_api.resource_data_get_by_key, self.ctx, self.resource.id, 'test_resource_key') self.assertIsNotNone(res_data) class DBAPIEventTest(HeatTestCase): def setUp(self): super(DBAPIEventTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) def test_event_create_get(self): event = create_event(self.ctx) ret_event = db_api.event_get(self.ctx, event.id) self.assertIsNotNone(ret_event) self.assertEqual('test_stack_id', ret_event.stack_id) self.assertEqual('create', ret_event.resource_action) self.assertEqual('complete', ret_event.resource_status) self.assertEqual('res', ret_event.resource_name) self.assertEqual(UUID1, ret_event.physical_resource_id) self.assertEqual('create_complete', ret_event.resource_status_reason) self.assertEqual({'name': 'foo'}, ret_event.resource_properties) def test_event_get_all(self): self.stack1 = create_stack(self.ctx, self.template, self.user_creds, tenant='tenant1') self.stack2 = create_stack(self.ctx, self.template, self.user_creds, tenant='tenant2') values = [ {'stack_id': self.stack1.id, 'resource_name': 'res1'}, {'stack_id': self.stack1.id, 'resource_name': 'res2'}, {'stack_id': self.stack2.id, 'resource_name': 'res3'}, ] [create_event(self.ctx, **val) for val in values] events = db_api.event_get_all(self.ctx) self.assertEqual(3, len(events)) stack_ids = [event.stack_id for event in events] res_names = [event.resource_name for event in events] [(self.assertIn(val['stack_id'], stack_ids), self.assertIn(val['resource_name'], res_names)) for val in values] def test_event_get_all_by_tenant(self): self.stack1 = create_stack(self.ctx, self.template, self.user_creds, tenant='tenant1') self.stack2 = create_stack(self.ctx, self.template, self.user_creds, tenant='tenant2') values = [ {'stack_id': self.stack1.id, 'resource_name': 'res1'}, {'stack_id': self.stack1.id, 'resource_name': 'res2'}, {'stack_id': self.stack2.id, 'resource_name': 'res3'}, ] [create_event(self.ctx, **val) for val in values] self.ctx.tenant_id = 'tenant1' events = db_api.event_get_all_by_tenant(self.ctx) self.assertEqual(2, len(events)) self.ctx.tenant_id = 'tenant2' events = db_api.event_get_all_by_tenant(self.ctx) self.assertEqual(1, len(events)) def test_event_get_all_by_stack(self): self.stack1 = create_stack(self.ctx, self.template, self.user_creds) self.stack2 = create_stack(self.ctx, self.template, self.user_creds) values = [ {'stack_id': self.stack1.id, 'resource_name': 'res1'}, {'stack_id': self.stack1.id, 'resource_name': 'res2'}, {'stack_id': self.stack2.id, 'resource_name': 'res3'}, ] [create_event(self.ctx, **val) for val in values] self.ctx.tenant_id = 'tenant1' events = db_api.event_get_all_by_stack(self.ctx, self.stack1.id) self.assertEqual(2, len(events)) self.ctx.tenant_id = 'tenant2' events = db_api.event_get_all_by_stack(self.ctx, self.stack2.id) self.assertEqual(1, len(events)) def test_event_count_all_by_stack(self): self.stack1 = create_stack(self.ctx, self.template, self.user_creds) self.stack2 = create_stack(self.ctx, self.template, self.user_creds) values = [ {'stack_id': self.stack1.id, 'resource_name': 'res1'}, {'stack_id': self.stack1.id, 'resource_name': 'res2'}, {'stack_id': self.stack2.id, 'resource_name': 'res3'}, ] [create_event(self.ctx, **val) for val in values] self.assertEqual(2, db_api.event_count_all_by_stack(self.ctx, self.stack1.id)) self.assertEqual(1, db_api.event_count_all_by_stack(self.ctx, self.stack2.id)) def test_event_resource_status_reason_truncate(self): event = create_event(self.ctx, resource_status_reason='a' * 1024) ret_event = db_api.event_get(self.ctx, event.id) self.assertEqual('a' * 255, ret_event.resource_status_reason) class DBAPIWatchRuleTest(HeatTestCase): def setUp(self): super(DBAPIWatchRuleTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) self.stack = create_stack(self.ctx, self.template, self.user_creds) def test_watch_rule_create_get(self): watch_rule = create_watch_rule(self.ctx, self.stack) ret_wr = db_api.watch_rule_get(self.ctx, watch_rule.id) self.assertIsNotNone(ret_wr) self.assertEqual('test_rule', ret_wr.name) self.assertEqual('{"foo": "123"}', dumps(ret_wr.rule)) self.assertEqual('normal', ret_wr.state) self.assertEqual(self.stack.id, ret_wr.stack_id) def test_watch_rule_get_by_name(self): watch_rule = create_watch_rule(self.ctx, self.stack) ret_wr = db_api.watch_rule_get_by_name(self.ctx, watch_rule.name) self.assertIsNotNone(ret_wr) self.assertEqual('test_rule', ret_wr.name) def test_watch_rule_get_all(self): values = [ {'name': 'rule1'}, {'name': 'rule2'}, {'name': 'rule3'}, ] [create_watch_rule(self.ctx, self.stack, **val) for val in values] wrs = db_api.watch_rule_get_all(self.ctx) self.assertEqual(3, len(wrs)) names = [wr.name for wr in wrs] [self.assertIn(val['name'], names) for val in values] def test_watch_rule_get_all_by_stack(self): self.stack1 = create_stack(self.ctx, self.template, self.user_creds) values = [ {'name': 'rule1', 'stack_id': self.stack.id}, {'name': 'rule2', 'stack_id': self.stack1.id}, {'name': 'rule3', 'stack_id': self.stack1.id}, ] [create_watch_rule(self.ctx, self.stack, **val) for val in values] wrs = db_api.watch_rule_get_all_by_stack(self.ctx, self.stack.id) self.assertEqual(1, len(wrs)) wrs = db_api.watch_rule_get_all_by_stack(self.ctx, self.stack1.id) self.assertEqual(2, len(wrs)) def test_watch_rule_update(self): watch_rule = create_watch_rule(self.ctx, self.stack) values = { 'name': 'test_rule_1', 'rule': loads('{"foo": "bar"}'), 'state': 'nodata', } db_api.watch_rule_update(self.ctx, watch_rule.id, values) watch_rule = db_api.watch_rule_get(self.ctx, watch_rule.id) self.assertEqual('test_rule_1', watch_rule.name) self.assertEqual('{"foo": "bar"}', dumps(watch_rule.rule)) self.assertEqual('nodata', watch_rule.state) self.assertRaises(exception.NotFound, db_api.watch_rule_update, self.ctx, UUID2, values) def test_watch_rule_delete(self): watch_rule = create_watch_rule(self.ctx, self.stack) create_watch_data(self.ctx, watch_rule) db_api.watch_rule_delete(self.ctx, watch_rule.id) self.assertIsNone(db_api.watch_rule_get(self.ctx, watch_rule.id)) self.assertRaises(exception.NotFound, db_api.watch_rule_delete, self.ctx, UUID2) #Testing associated watch data deletion self.assertEqual([], db_api.watch_data_get_all(self.ctx)) class DBAPIWatchDataTest(HeatTestCase): def setUp(self): super(DBAPIWatchDataTest, self).setUp() self.ctx = utils.dummy_context() utils.setup_dummy_db() utils.reset_dummy_db() self.template = create_raw_template(self.ctx) self.user_creds = create_user_creds(self.ctx) self.stack = create_stack(self.ctx, self.template, self.user_creds) self.watch_rule = create_watch_rule(self.ctx, self.stack) def test_watch_data_create(self): create_watch_data(self.ctx, self.watch_rule) ret_data = db_api.watch_data_get_all(self.ctx) self.assertEqual(1, len(ret_data)) self.assertEqual('{"foo": "bar"}', dumps(ret_data[0].data)) self.assertEqual(self.watch_rule.id, ret_data[0].watch_rule_id) def test_watch_data_get_all(self): values = [ {'data': loads('{"foo": "d1"}')}, {'data': loads('{"foo": "d2"}')}, {'data': loads('{"foo": "d3"}')} ] [create_watch_data(self.ctx, self.watch_rule, **val) for val in values] watch_data = db_api.watch_data_get_all(self.ctx) self.assertEqual(3, len(watch_data)) data = [wd.data for wd in watch_data] [self.assertIn(val['data'], data) for val in values] heat-2014.1.5/heat/tests/test_s3.py0000664000567000056700000002355512540642614020064 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. from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import resource from heat.engine.resources import s3 from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils swiftclient = try_import('swiftclient.client') swift_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test S3 Bucket resources", "Resources" : { "S3BucketWebsite" : { "Type" : "AWS::S3::Bucket", "DeletionPolicy" : "Delete", "Properties" : { "AccessControl" : "PublicRead", "WebsiteConfiguration" : { "IndexDocument" : "index.html", "ErrorDocument" : "error.html" } } }, "SwiftContainer": { "Type": "OS::Swift::Container", "Properties": { "S3Bucket": {"Ref" : "S3Bucket"}, } }, "S3Bucket" : { "Type" : "AWS::S3::Bucket", "Properties" : { "AccessControl" : "Private" } }, "S3Bucket_with_tags" : { "Type" : "AWS::S3::Bucket", "Properties" : { "Tags" : [{"Key": "greeting", "Value": "hello"}, {"Key": "location", "Value": "here"}] } } } } ''' class s3Test(HeatTestCase): @skipIf(swiftclient is None, 'unable to import swiftclient') def setUp(self): super(s3Test, self).setUp() self.m.CreateMock(swiftclient.Connection) self.m.StubOutWithMock(swiftclient.Connection, 'put_container') self.m.StubOutWithMock(swiftclient.Connection, 'delete_container') self.m.StubOutWithMock(swiftclient.Connection, 'get_auth') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_resource(self, t, stack, resource_name): rsrc = s3.S3Bucket('test_resource', t['Resources'][resource_name], stack) scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) return rsrc def test_attributes(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username'} ).AndReturn(None) swiftclient.Connection.get_auth().MultipleTimes().AndReturn( ('http://server.test:8080/v_2', None)) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') ref_id = rsrc.FnGetRefId() self.assertEqual(container_name, ref_id) self.assertEqual('server.test', rsrc.FnGetAtt('DomainName')) url = 'http://server.test:8080/v_2/%s' % ref_id self.assertEqual(url, rsrc.FnGetAtt('WebsiteURL')) self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo') self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_public_read(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( utils.PhysName('test_stack', 'test_resource'), {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': '.r:*'}).AndReturn(None) swiftclient.Connection.delete_container( container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) properties = t['Resources']['S3Bucket']['Properties'] properties['AccessControl'] = 'PublicRead' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_tags(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( utils.PhysName('test_stack', 'test_resource'), {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username', 'X-Container-Meta-S3-Tag-greeting': 'hello', 'X-Container-Meta-S3-Tag-location': 'here'}).AndReturn(None) swiftclient.Connection.delete_container( container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket_with_tags') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_public_read_write(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Write': '.r:*', 'X-Container-Read': '.r:*'}).AndReturn(None) swiftclient.Connection.delete_container( container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) properties = t['Resources']['S3Bucket']['Properties'] properties['AccessControl'] = 'PublicReadWrite' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_authenticated_read(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) properties = t['Resources']['S3Bucket']['Properties'] properties['AccessControl'] = 'AuthenticatedRead' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_website(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Meta-Web-Error': 'error.html', 'X-Container-Meta-Web-Index': 'index.html', 'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': '.r:*'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3BucketWebsite') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_delete_exception(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username'}).AndReturn(None) swiftclient.Connection.delete_container(container_name).AndRaise( swiftclient.ClientException('Test delete failure')) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() def test_delete_retain(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) # first run, with retain policy swiftclient.Connection.put_container( utils.PhysName('test_stack', 'test_resource'), {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username'}).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) bucket = t['Resources']['S3Bucket'] bucket['DeletionPolicy'] = 'Retain' stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_stack_user.py0000664000567000056700000003506512540642614021701 0ustar jenkinsjenkins00000000000000# vim: tabstop=4 shiftwidth=4 softtabstop=4 # 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. from keystoneclient import exceptions as kc_exceptions from heat.common import exception from heat.common import short_id from heat.common import template_format from heat.db import api as db_api from heat.engine import resource from heat.engine import scheduler from heat.engine import stack_user from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import generic_resource from heat.tests import utils user_template = ''' heat_template_version: 2013-05-23 resources: user: type: StackUserResourceType ''' class StackUserTest(HeatTestCase): def setUp(self): super(StackUserTest, self).setUp() utils.setup_dummy_db() resource._register_class('StackUserResourceType', generic_resource.StackUserResource) self.fc = fakes.FakeKeystoneClient() def tearDown(self): super(StackUserTest, self).tearDown() utils.reset_dummy_db() def _user_create(self, stack_name, project_id, user_id, resource_name='user', create_project=True): t = template_format.parse(user_template) stack = utils.parse_stack(t, stack_name=stack_name) rsrc = stack[resource_name] self.m.StubOutWithMock(stack_user.StackUser, 'keystone') stack_user.StackUser.keystone().MultipleTimes().AndReturn(self.fc) if create_project: self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'create_stack_domain_project') fakes.FakeKeystoneClient.create_stack_domain_project( stack.id).AndReturn(project_id) else: stack.set_stack_user_project_id(project_id) rsrc._store() self.m.StubOutWithMock(short_id, 'get_id') short_id.get_id(rsrc.id).AndReturn('aabbcc') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'create_stack_domain_user') expected_username = '%s-%s-%s' % (stack_name, resource_name, 'aabbcc') fakes.FakeKeystoneClient.create_stack_domain_user( username=expected_username, password=None, project_id=project_id).AndReturn(user_id) return rsrc def test_handle_create_no_stack_project(self): rsrc = self._user_create(stack_name='user_test123', project_id='aproject123', user_id='auser123') self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual({'user_id': 'auser123'}, rs_data) self.m.VerifyAll() def test_handle_create_existing_project(self): rsrc = self._user_create(stack_name='user_test456', project_id='aproject456', user_id='auser456', create_project=False) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual({'user_id': 'auser456'}, rs_data) self.m.VerifyAll() def test_handle_delete(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'delete_stack_domain_user') fakes.FakeKeystoneClient.delete_stack_domain_user( user_id='auserdel', project_id='aprojectdel').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_handle_delete_not_found(self): rsrc = self._user_create(stack_name='user_testdel2', project_id='aprojectdel2', user_id='auserdel2') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'delete_stack_domain_user') fakes.FakeKeystoneClient.delete_stack_domain_user( user_id='auserdel2', project_id='aprojectdel2').AndRaise( kc_exceptions.NotFound) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_handle_delete_noid(self): rsrc = self._user_create(stack_name='user_testdel2', project_id='aprojectdel2', user_id='auserdel2') self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) db_api.resource_data_delete(rsrc, 'user_id') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_handle_suspend(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'disable_stack_domain_user') fakes.FakeKeystoneClient.disable_stack_domain_user( user_id='auserdel', project_id='aprojectdel').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_handle_suspend_legacy(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'disable_stack_domain_user') fakes.FakeKeystoneClient.disable_stack_domain_user( user_id='auserdel', project_id='aprojectdel').AndRaise(ValueError) self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'disable_stack_user') fakes.FakeKeystoneClient.disable_stack_user( user_id='auserdel').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_handle_resume(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'enable_stack_domain_user') fakes.FakeKeystoneClient.enable_stack_domain_user( user_id='auserdel', project_id='aprojectdel').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_handle_resume_legacy(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'enable_stack_domain_user') fakes.FakeKeystoneClient.enable_stack_domain_user( user_id='auserdel', project_id='aprojectdel').AndRaise(ValueError) self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'enable_stack_user') fakes.FakeKeystoneClient.enable_stack_user( user_id='auserdel').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_keypair(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') # create_stack_domain_user_keypair(self, user_id, project_id): self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'create_stack_domain_user_keypair') fakes.FakeKeystoneClient.create_stack_domain_user_keypair( user_id='auserdel', project_id='aprojectdel').AndReturn( self.fc.creds) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) kp = rsrc._create_keypair() self.assertEqual(self.fc.credential_id, kp.id) self.assertEqual(self.fc.access, kp.access) self.assertEqual(self.fc.secret, kp.secret) rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual(self.fc.credential_id, rs_data['credential_id']) self.assertEqual(self.fc.access, rs_data['access_key']) self.assertEqual(self.fc.secret, rs_data['secret_key']) self.m.VerifyAll() def test_create_keypair_error(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') # create_stack_domain_user_keypair(self, user_id, project_id): self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'create_stack_domain_user_keypair') fakes.FakeKeystoneClient.create_stack_domain_user_keypair( user_id='auserdel', project_id='aprojectdel').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertRaises(exception.Error, rsrc._create_keypair) self.m.VerifyAll() def test_delete_keypair(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'delete_stack_domain_user_keypair') fakes.FakeKeystoneClient.delete_stack_domain_user_keypair( user_id='auserdel', project_id='aprojectdel', credential_id='acredential').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) db_api.resource_data_set(rsrc, 'credential_id', 'acredential') db_api.resource_data_set(rsrc, 'access_key', 'access123') db_api.resource_data_set(rsrc, 'secret_key', 'verysecret') rsrc._delete_keypair() rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual({'user_id': 'auserdel'}, rs_data) self.m.VerifyAll() def test_delete_keypair_no_credential_id(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') rsrc._delete_keypair() def test_delete_keypair_legacy(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'delete_stack_domain_user_keypair') fakes.FakeKeystoneClient.delete_stack_domain_user_keypair( user_id='auserdel', project_id='aprojectdel', credential_id='acredential').AndRaise(ValueError()) self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'delete_ec2_keypair') fakes.FakeKeystoneClient.delete_ec2_keypair( user_id='auserdel', credential_id='acredential').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) db_api.resource_data_set(rsrc, 'credential_id', 'acredential') db_api.resource_data_set(rsrc, 'access_key', 'access123') db_api.resource_data_set(rsrc, 'secret_key', 'verysecret') rsrc._delete_keypair() rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual({'user_id': 'auserdel'}, rs_data) self.m.VerifyAll() def test_delete_keypair_notfound(self): rsrc = self._user_create(stack_name='user_testdel', project_id='aprojectdel', user_id='auserdel') self.m.StubOutWithMock(fakes.FakeKeystoneClient, 'delete_stack_domain_user_keypair') fakes.FakeKeystoneClient.delete_stack_domain_user_keypair( user_id='auserdel', project_id='aprojectdel', credential_id='acredential').AndReturn(None) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) db_api.resource_data_set(rsrc, 'credential_id', 'acredential') rsrc._delete_keypair() rs_data = db_api.resource_data_get_all(rsrc) self.assertEqual({'user_id': 'auserdel'}, rs_data) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_parser.py0000664000567000056700000033766312540642614021043 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. import collections import json import time from keystoneclient import exceptions as kc_exceptions import mock from mox import IgnoreArg from oslo.config import cfg from six.moves import xrange from heat.common import exception from heat.common import template_format from heat.common import urlfetch import heat.db.api as db_api import heat.engine.cfn.functions from heat.engine import clients from heat.engine import environment from heat.engine import function from heat.engine import parameters from heat.engine import parser from heat.engine import resource from heat.engine import scheduler from heat.engine import template from heat.tests.common import HeatTestCase from heat.tests.fakes import FakeKeystoneClient from heat.tests import generic_resource as generic_rsrc from heat.tests import utils from heat.tests.v1_1 import fakes def join(raw): tmpl = parser.Template(mapping_template) return function.resolve(tmpl.parse(None, raw)) class ParserTest(HeatTestCase): def test_list(self): raw = ['foo', 'bar', 'baz'] parsed = join(raw) for i in xrange(len(raw)): self.assertEqual(raw[i], parsed[i]) self.assertIsNot(raw, parsed) def test_dict(self): raw = {'foo': 'bar', 'blarg': 'wibble'} parsed = join(raw) for k in raw: self.assertEqual(raw[k], parsed[k]) self.assertIsNot(raw, parsed) def test_dict_list(self): raw = {'foo': ['bar', 'baz'], 'blarg': 'wibble'} parsed = join(raw) self.assertEqual(raw['blarg'], parsed['blarg']) for i in xrange(len(raw['foo'])): self.assertEqual(raw['foo'][i], parsed['foo'][i]) self.assertIsNot(raw, parsed) self.assertIsNot(raw['foo'], parsed['foo']) def test_list_dict(self): raw = [{'foo': 'bar', 'blarg': 'wibble'}, 'baz', 'quux'] parsed = join(raw) for i in xrange(1, len(raw)): self.assertEqual(raw[i], parsed[i]) for k in raw[0]: self.assertEqual(raw[0][k], parsed[0][k]) self.assertIsNot(raw, parsed) self.assertIsNot(raw[0], parsed[0]) def test_join(self): raw = {'Fn::Join': [' ', ['foo', 'bar', 'baz']]} self.assertEqual('foo bar baz', join(raw)) def test_join_none(self): raw = {'Fn::Join': [' ', ['foo', None, 'baz']]} self.assertEqual('foo baz', join(raw)) def test_join_list(self): raw = [{'Fn::Join': [' ', ['foo', 'bar', 'baz']]}, 'blarg', 'wibble'] parsed = join(raw) self.assertEqual('foo bar baz', parsed[0]) for i in xrange(1, len(raw)): self.assertEqual(raw[i], parsed[i]) self.assertIsNot(raw, parsed) def test_join_dict_val(self): raw = {'quux': {'Fn::Join': [' ', ['foo', 'bar', 'baz']]}, 'blarg': 'wibble'} parsed = join(raw) self.assertEqual('foo bar baz', parsed['quux']) self.assertEqual(raw['blarg'], parsed['blarg']) self.assertIsNot(raw, parsed) mapping_template = template_format.parse('''{ "AWSTemplateFormatVersion" : "2010-09-09", "Mappings" : { "ValidMapping" : { "TestKey" : { "TestValue" : "wibble" } }, "InvalidMapping" : { "ValueList" : [ "foo", "bar" ], "ValueString" : "baz" }, "MapList": [ "foo", { "bar" : "baz" } ], "MapString": "foobar" } }''') empty_template = template_format.parse('''{ "HeatTemplateFormatVersion" : "2012-12-12", }''') parameter_template = template_format.parse('''{ "HeatTemplateFormatVersion" : "2012-12-12", "Parameters" : { "foo" : { "Type" : "String" }, "blarg" : { "Type" : "String", "Default": "quux" } } }''') resource_template = template_format.parse('''{ "HeatTemplateFormatVersion" : "2012-12-12", "Resources" : { "foo" : { "Type" : "GenericResourceType" }, "blarg" : { "Type" : "GenericResourceType" } } }''') class TemplateTest(HeatTestCase): def setUp(self): super(TemplateTest, self).setUp() self.ctx = utils.dummy_context() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) @staticmethod def resolve(snippet, template, stack=None): return function.resolve(template.parse(stack, snippet)) def test_defaults(self): empty = parser.Template({}) self.assertNotIn('AWSTemplateFormatVersion', empty) self.assertEqual('No description', empty['Description']) self.assertEqual({}, empty['Mappings']) self.assertEqual({}, empty['Resources']) self.assertEqual({}, empty['Outputs']) def test_aws_version(self): tmpl = parser.Template(mapping_template) self.assertEqual(('AWSTemplateFormatVersion', '2010-09-09'), tmpl.version) def test_heat_version(self): tmpl = parser.Template(resource_template) self.assertEqual(('HeatTemplateFormatVersion', '2012-12-12'), tmpl.version) def test_invalid_template(self): scanner_error = ''' 1 Mappings: ValidMapping: TestKey: TestValue ''' parser_error = ''' Mappings: ValidMapping: TestKey: {TestKey1: "Value1" TestKey2: "Value2"} ''' self.assertRaises(ValueError, template_format.parse, scanner_error) self.assertRaises(ValueError, template_format.parse, parser_error) def test_invalid_section(self): tmpl = parser.Template({'Foo': ['Bar']}) self.assertNotIn('Foo', tmpl) def test_find_in_map(self): tmpl = parser.Template(mapping_template) stack = parser.Stack(self.ctx, 'test', tmpl) find = {'Fn::FindInMap': ["ValidMapping", "TestKey", "TestValue"]} self.assertEqual("wibble", self.resolve(find, tmpl, stack)) def test_find_in_invalid_map(self): tmpl = parser.Template(mapping_template) stack = parser.Stack(self.ctx, 'test', tmpl) finds = ({'Fn::FindInMap': ["InvalidMapping", "ValueList", "foo"]}, {'Fn::FindInMap': ["InvalidMapping", "ValueString", "baz"]}, {'Fn::FindInMap': ["MapList", "foo", "bar"]}, {'Fn::FindInMap': ["MapString", "foo", "bar"]}) for find in finds: self.assertRaises((KeyError, TypeError), self.resolve, find, tmpl, stack) def test_bad_find_in_map(self): tmpl = parser.Template(mapping_template) stack = parser.Stack(self.ctx, 'test', tmpl) finds = ({'Fn::FindInMap': "String"}, {'Fn::FindInMap': {"Dict": "String"}}, {'Fn::FindInMap': ["ShortList", "foo"]}, {'Fn::FindInMap': ["ReallyShortList"]}) for find in finds: self.assertRaises(KeyError, self.resolve, find, tmpl, stack) def test_param_refs(self): tmpl = parser.Template(parameter_template) env = environment.Environment({'foo': 'bar', 'blarg': 'wibble'}) stack = parser.Stack(self.ctx, 'test', tmpl, env) p_snippet = {"Ref": "foo"} self.assertEqual("bar", self.resolve(p_snippet, tmpl, stack)) def test_param_ref_missing(self): tmpl = parser.Template(parameter_template) env = environment.Environment({'foo': 'bar'}) stack = parser.Stack(self.ctx, 'test', tmpl, env) stack.env = environment.Environment({}) stack.parameters = parameters.Parameters(stack.identifier(), tmpl) snippet = {"Ref": "foo"} self.assertRaises(exception.UserParameterMissing, self.resolve, snippet, tmpl, stack) def test_resource_refs(self): tmpl = parser.Template(resource_template) stack = parser.Stack(self.ctx, 'test', tmpl) self.m.StubOutWithMock(stack['foo'], 'FnGetRefId') stack['foo'].FnGetRefId().MultipleTimes().AndReturn('bar') self.m.ReplayAll() r_snippet = {"Ref": "foo"} self.assertEqual("bar", self.resolve(r_snippet, tmpl, stack)) self.m.VerifyAll() def test_resource_refs_param(self): tmpl = parser.Template(resource_template) stack = parser.Stack(self.ctx, 'test', tmpl) p_snippet = {"Ref": "baz"} parsed = tmpl.parse(stack, p_snippet) self.assertTrue(isinstance(parsed, heat.engine.cfn.functions.ParamRef)) def test_select_from_list(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": ["1", ["foo", "bar"]]} self.assertEqual("bar", self.resolve(data, tmpl)) def test_select_from_list_integer_index(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": [1, ["foo", "bar"]]} self.assertEqual("bar", self.resolve(data, tmpl)) def test_select_from_list_out_of_bound(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": ["0", ["foo", "bar"]]} self.assertEqual("foo", self.resolve(data, tmpl)) data = {"Fn::Select": ["1", ["foo", "bar"]]} self.assertEqual("bar", self.resolve(data, tmpl)) data = {"Fn::Select": ["2", ["foo", "bar"]]} self.assertEqual("", self.resolve(data, tmpl)) def test_select_from_dict(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": ["red", {"red": "robin", "re": "foo"}]} self.assertEqual("robin", self.resolve(data, tmpl)) def test_select_from_none(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": ["red", None]} self.assertEqual("", self.resolve(data, tmpl)) def test_select_from_dict_not_existing(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": ["green", {"red": "robin", "re": "foo"}]} self.assertEqual("", self.resolve(data, tmpl)) def test_select_from_serialized_json_map(self): tmpl = parser.Template(empty_template) js = json.dumps({"red": "robin", "re": "foo"}) data = {"Fn::Select": ["re", js]} self.assertEqual("foo", self.resolve(data, tmpl)) def test_select_from_serialized_json_list(self): tmpl = parser.Template(empty_template) js = json.dumps(["foo", "fee", "fum"]) data = {"Fn::Select": ["0", js]} self.assertEqual("foo", self.resolve(data, tmpl)) def test_select_empty_string(self): tmpl = parser.Template(empty_template) data = {"Fn::Select": ["0", '']} self.assertEqual("", self.resolve(data, tmpl)) data = {"Fn::Select": ["1", '']} self.assertEqual("", self.resolve(data, tmpl)) data = {"Fn::Select": ["one", '']} self.assertEqual("", self.resolve(data, tmpl)) def test_join(self): tmpl = parser.Template(empty_template) join = {"Fn::Join": [" ", ["foo", "bar"]]} self.assertEqual("foo bar", self.resolve(join, tmpl)) def test_split_ok(self): tmpl = parser.Template(empty_template) data = {"Fn::Split": [";", "foo; bar; achoo"]} self.assertEqual(['foo', ' bar', ' achoo'], self.resolve(data, tmpl)) def test_split_no_delim_in_str(self): tmpl = parser.Template(empty_template) data = {"Fn::Split": [";", "foo, bar, achoo"]} self.assertEqual(['foo, bar, achoo'], self.resolve(data, tmpl)) def test_base64(self): tmpl = parser.Template(empty_template) snippet = {"Fn::Base64": "foobar"} # For now, the Base64 function just returns the original text, and # does not convert to base64 (see issue #133) self.assertEqual("foobar", self.resolve(snippet, tmpl)) def test_get_azs(self): tmpl = parser.Template(empty_template) snippet = {"Fn::GetAZs": ""} self.assertEqual(["nova"], self.resolve(snippet, tmpl)) def test_get_azs_with_stack(self): tmpl = parser.Template(empty_template) snippet = {"Fn::GetAZs": ""} stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') fc = fakes.FakeClient() clients.OpenStackClients.nova().MultipleTimes().AndReturn(fc) self.m.ReplayAll() self.assertEqual(["nova1"], self.resolve(snippet, tmpl, stack)) def test_replace_string_values(self): tmpl = parser.Template(empty_template) snippet = {"Fn::Replace": [ {'$var1': 'foo', '%var2%': 'bar'}, '$var1 is %var2%' ]} self.assertEqual('foo is bar', self.resolve(snippet, tmpl)) def test_replace_number_values(self): tmpl = parser.Template(empty_template) snippet = {"Fn::Replace": [ {'$var1': 1, '%var2%': 2}, '$var1 is not %var2%' ]} self.assertEqual('1 is not 2', self.resolve(snippet, tmpl)) snippet = {"Fn::Replace": [ {'$var1': 1.3, '%var2%': 2.5}, '$var1 is not %var2%' ]} self.assertEqual('1.3 is not 2.5', self.resolve(snippet, tmpl)) def test_replace_none_values(self): tmpl = parser.Template(empty_template) snippet = {"Fn::Replace": [ {'$var1': None, '${var2}': None}, '"$var1" is "${var2}"' ]} self.assertEqual('"" is ""', self.resolve(snippet, tmpl)) def test_replace_missing_key(self): tmpl = parser.Template(empty_template) snippet = {"Fn::Replace": [ {'$var1': 'foo', 'var2': 'bar'}, '"$var1" is "${var3}"' ]} self.assertEqual('"foo" is "${var3}"', self.resolve(snippet, tmpl)) def test_replace_param_values(self): tmpl = parser.Template(parameter_template) env = environment.Environment({'foo': 'wibble'}) stack = parser.Stack(self.ctx, 'test_stack', tmpl, env) snippet = {"Fn::Replace": [ {'$var1': {'Ref': 'foo'}, '%var2%': {'Ref': 'blarg'}}, '$var1 is %var2%' ]} self.assertEqual('wibble is quux', self.resolve(snippet, tmpl, stack)) def test_member_list2map_good(self): tmpl = parser.Template(empty_template) snippet = {"Fn::MemberListToMap": [ 'Name', 'Value', ['.member.0.Name=metric', '.member.0.Value=cpu', '.member.1.Name=size', '.member.1.Value=56']]} self.assertEqual({'metric': 'cpu', 'size': '56'}, self.resolve(snippet, tmpl)) def test_member_list2map_good2(self): tmpl = parser.Template(empty_template) snippet = {"Fn::MemberListToMap": [ 'Key', 'Value', ['.member.2.Key=metric', '.member.2.Value=cpu', '.member.5.Key=size', '.member.5.Value=56']]} self.assertEqual({'metric': 'cpu', 'size': '56'}, self.resolve(snippet, tmpl)) def test_resource_facade(self): metadata_snippet = {'Fn::ResourceFacade': 'Metadata'} deletion_policy_snippet = {'Fn::ResourceFacade': 'DeletionPolicy'} update_policy_snippet = {'Fn::ResourceFacade': 'UpdatePolicy'} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.t = {'DeletionPolicy': 'Retain', 'UpdatePolicy': {"blarg": "wibble"}} parent_resource.stack = parser.Stack(self.ctx, 'toplevel_stack', parser.Template({})) stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), parent_resource=parent_resource) self.assertEqual({"foo": "bar"}, self.resolve(metadata_snippet, stack.t, stack)) self.assertEqual('Retain', self.resolve(deletion_policy_snippet, stack.t, stack)) self.assertEqual({"blarg": "wibble"}, self.resolve(update_policy_snippet, stack.t, stack)) def test_resource_facade_function(self): deletion_policy_snippet = {'Fn::ResourceFacade': 'DeletionPolicy'} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.stack = parser.Stack(self.ctx, 'toplevel_stack', parser.Template({})) parent_snippet = {'DeletionPolicy': {'Fn::Join': ['eta', ['R', 'in']]}} parent_tmpl = parent_resource.stack.t.parse(parent_resource.stack, parent_snippet) parent_resource.t = parent_tmpl stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), parent_resource=parent_resource) self.assertEqual('Retain', self.resolve(deletion_policy_snippet, stack.t, stack)) def test_resource_facade_invalid_arg(self): snippet = {'Fn::ResourceFacade': 'wibble'} stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) error = self.assertRaises(ValueError, self.resolve, snippet, stack.t, stack) self.assertIn(snippet.keys()[0], str(error)) def test_resource_facade_missing_deletion_policy(self): snippet = {'Fn::ResourceFacade': 'DeletionPolicy'} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.t = {} parent_resource.stack = parser.Stack(self.ctx, 'toplevel_stack', parser.Template({})) stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), parent_resource=parent_resource) self.assertEqual('Delete', self.resolve(snippet, stack.t, stack)) def test_prevent_parameters_access(self): expected_description = "This can be accessed" tmpl = parser.Template({'Description': expected_description, 'Parameters': {'foo': {'Type': 'String', 'Required': True}}}) self.assertEqual(expected_description, tmpl['Description']) keyError = self.assertRaises(KeyError, tmpl.__getitem__, 'Parameters') self.assertIn("can not be accessed directly", str(keyError)) def test_parameters_section_not_iterable(self): expected_description = "This can be accessed" tmpl = parser.Template({'AWSTemplateFormatVersion': '2010-09-09', 'Description': expected_description, 'Parameters': {'foo': {'Type': 'String', 'Required': True}}}) self.assertEqual(expected_description, tmpl['Description']) self.assertNotIn('Parameters', tmpl.keys()) class TemplateFnErrorTest(HeatTestCase): scenarios = [ ('select_from_list_not_int', dict(expect=TypeError, snippet={"Fn::Select": ["one", ["foo", "bar"]]})), ('select_from_dict_not_str', dict(expect=TypeError, snippet={"Fn::Select": ["1", {"red": "robin", "re": "foo"}]})), ('select_from_serialized_json_wrong', dict(expect=ValueError, snippet={"Fn::Select": ["not", "no json"]})), ('select_wrong_num_args_1', dict(expect=ValueError, snippet={"Fn::Select": []})), ('select_wrong_num_args_2', dict(expect=ValueError, snippet={"Fn::Select": ["4"]})), ('select_wrong_num_args_3', dict(expect=ValueError, snippet={"Fn::Select": ["foo", {"foo": "bar"}, ""]})), ('select_wrong_num_args_4', dict(expect=TypeError, snippet={'Fn::Select': [['f'], {'f': 'food'}]})), ('split_no_delim', dict(expect=ValueError, snippet={"Fn::Split": ["foo, bar, achoo"]})), ('split_no_list', dict(expect=TypeError, snippet={"Fn::Split": "foo, bar, achoo"})), ('base64_list', dict(expect=TypeError, snippet={"Fn::Base64": ["foobar"]})), ('base64_dict', dict(expect=TypeError, snippet={"Fn::Base64": {"foo": "bar"}})), ('replace_list_value', dict(expect=TypeError, snippet={"Fn::Replace": [ {'$var1': 'foo', '%var2%': ['bar']}, '$var1 is %var2%']})), ('replace_list_mapping', dict(expect=TypeError, snippet={"Fn::Replace": [ ['var1', 'foo', 'var2', 'bar'], '$var1 is ${var2}']})), ('replace_dict', dict(expect=TypeError, snippet={"Fn::Replace": {}})), ('replace_missing_template', dict(expect=ValueError, snippet={"Fn::Replace": [['var1', 'foo', 'var2', 'bar']]})), ('replace_none_template', dict(expect=TypeError, snippet={"Fn::Replace": [['var2', 'bar'], None]})), ('replace_list_string', dict(expect=TypeError, snippet={"Fn::Replace": [ {'var1': 'foo', 'var2': 'bar'}, ['$var1 is ${var2}']]})), ('join_string', dict(expect=TypeError, snippet={"Fn::Join": [" ", "foo"]})), ('join_dict', dict(expect=TypeError, snippet={"Fn::Join": [" ", {"foo": "bar"}]})), ('join_wrong_num_args_1', dict(expect=ValueError, snippet={"Fn::Join": []})), ('join_wrong_num_args_2', dict(expect=ValueError, snippet={"Fn::Join": [" "]})), ('join_wrong_num_args_3', dict(expect=ValueError, snippet={"Fn::Join": [" ", {"foo": "bar"}, ""]})), ('join_string_nodelim', dict(expect=TypeError, snippet={"Fn::Join": "o"})), ('join_string_nodelim_1', dict(expect=TypeError, snippet={"Fn::Join": "oh"})), ('join_string_nodelim_2', dict(expect=TypeError, snippet={"Fn::Join": "ohh"})), ('join_dict_nodelim1', dict(expect=TypeError, snippet={"Fn::Join": {"foo": "bar"}})), ('join_dict_nodelim2', dict(expect=TypeError, snippet={"Fn::Join": {"foo": "bar", "blarg": "wibble"}})), ('join_dict_nodelim3', dict(expect=TypeError, snippet={"Fn::Join": {"foo": "bar", "blarg": "wibble", "baz": "quux"}})), ('member_list2map_no_key_or_val', dict(expect=TypeError, snippet={"Fn::MemberListToMap": [ 'Key', ['.member.2.Key=metric', '.member.2.Value=cpu', '.member.5.Key=size', '.member.5.Value=56']]})), ('member_list2map_no_list', dict(expect=TypeError, snippet={"Fn::MemberListToMap": [ 'Key', '.member.2.Key=metric']})), ('member_list2map_not_string', dict(expect=TypeError, snippet={"Fn::MemberListToMap": [ 'Name', ['Value'], ['.member.0.Name=metric', '.member.0.Value=cpu', '.member.1.Name=size', '.member.1.Value=56']]})), ] def test_bad_input(self): tmpl = parser.Template(empty_template) resolve = lambda s: TemplateTest.resolve(s, tmpl) error = self.assertRaises(self.expect, resolve, self.snippet) self.assertIn(self.snippet.keys()[0], str(error)) class ResolveDataTest(HeatTestCase): def setUp(self): super(ResolveDataTest, self).setUp() self.username = 'parser_stack_test_user' utils.setup_dummy_db() self.ctx = utils.dummy_context() self.stack = parser.Stack(self.ctx, 'resolve_test_stack', template.Template({}), environment.Environment({})) def resolve(self, snippet): return function.resolve(self.stack.t.parse(self.stack, snippet)) def test_join_split(self): # join snippet = {'Fn::Join': [';', ['one', 'two', 'three']]} self.assertEqual('one;two;three', self.resolve(snippet)) # join then split snippet = {'Fn::Split': [';', snippet]} self.assertEqual(['one', 'two', 'three'], self.resolve(snippet)) def test_split_join_split_join(self): # each snippet in this test encapsulates # the snippet from the previous step, leading # to increasingly nested function calls # split snippet = {'Fn::Split': [',', 'one,two,three']} self.assertEqual(['one', 'two', 'three'], self.resolve(snippet)) # split then join snippet = {'Fn::Join': [';', snippet]} self.assertEqual('one;two;three', self.resolve(snippet)) # split then join then split snippet = {'Fn::Split': [';', snippet]} self.assertEqual(['one', 'two', 'three'], self.resolve(snippet)) # split then join then split then join snippet = {'Fn::Join': ['-', snippet]} self.assertEqual('one-two-three', self.resolve(snippet)) def test_join_recursive(self): raw = {'Fn::Join': ['\n', [{'Fn::Join': [' ', ['foo', 'bar']]}, 'baz']]} self.assertEqual('foo bar\nbaz', self.resolve(raw)) def test_base64_replace(self): raw = {'Fn::Base64': {'Fn::Replace': [ {'foo': 'bar'}, 'Meet at the foo']}} self.assertEqual('Meet at the bar', self.resolve(raw)) def test_replace_base64(self): raw = {'Fn::Replace': [{'foo': 'bar'}, { 'Fn::Base64': 'Meet at the foo'}]} self.assertEqual('Meet at the bar', self.resolve(raw)) def test_nested_selects(self): data = { 'a': ['one', 'two', 'three'], 'b': ['een', 'twee', {'d': 'D', 'e': 'E'}] } raw = {'Fn::Select': ['a', data]} self.assertEqual(data['a'], self.resolve(raw)) raw = {'Fn::Select': ['b', data]} self.assertEqual(data['b'], self.resolve(raw)) raw = { 'Fn::Select': ['1', { 'Fn::Select': ['b', data]}]} self.assertEqual('twee', self.resolve(raw)) raw = { 'Fn::Select': ['e', { 'Fn::Select': ['2', { 'Fn::Select': ['b', data]}]}]} self.assertEqual('E', self.resolve(raw)) def test_member_list_select(self): snippet = {'Fn::Select': ['metric', {"Fn::MemberListToMap": [ 'Name', 'Value', ['.member.0.Name=metric', '.member.0.Value=cpu', '.member.1.Name=size', '.member.1.Value=56']]}]} self.assertEqual('cpu', self.resolve(snippet)) class StackTest(HeatTestCase): def setUp(self): super(StackTest, self).setUp() self.username = 'parser_stack_test_user' utils.setup_dummy_db() self.ctx = utils.dummy_context() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) resource._register_class('ResourceWithPropsType', generic_rsrc.ResourceWithProps) resource._register_class('ResourceWithComplexAttributesType', generic_rsrc.ResourceWithComplexAttributes) self.m.ReplayAll() def test_stack_reads_tenant(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), tenant_id='bar') self.assertEqual('bar', stack.tenant_id) def test_stack_reads_tenant_from_context_if_empty(self): self.ctx.tenant_id = 'foo' stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), tenant_id=None) self.assertEqual('foo', stack.tenant_id) def test_stack_string_repr(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) expected = 'Stack "%s" [%s]' % (stack.name, stack.id) observed = str(stack) self.assertEqual(expected, observed) def test_state_defaults(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) self.assertEqual((None, None), stack.state) self.assertEqual('', stack.status_reason) def test_timeout_secs_default(self): cfg.CONF.set_override('stack_action_timeout', 1000) stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) self.assertIsNone(stack.timeout_mins) self.assertEqual(1000, stack.timeout_secs()) def test_timeout_secs(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), timeout_mins=10) self.assertEqual(600, stack.timeout_secs()) def test_no_auth_token(self): ctx = utils.dummy_context() ctx.auth_token = None self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( FakeKeystoneClient()) self.m.ReplayAll() stack = parser.Stack(ctx, 'test_stack', parser.Template({})) self.assertEqual('abcd1234', stack.clients.auth_token) self.m.VerifyAll() def test_state(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), action=parser.Stack.CREATE, status=parser.Stack.IN_PROGRESS) self.assertEqual((parser.Stack.CREATE, parser.Stack.IN_PROGRESS), stack.state) stack.state_set(parser.Stack.CREATE, parser.Stack.COMPLETE, 'test') self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), stack.state) stack.state_set(parser.Stack.DELETE, parser.Stack.COMPLETE, 'test') self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), stack.state) def test_state_deleted(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), action=parser.Stack.CREATE, status=parser.Stack.IN_PROGRESS) stack.id = '1234' # Simulate a deleted stack self.m.StubOutWithMock(db_api, 'stack_get') db_api.stack_get(stack.context, stack.id).AndReturn(None) self.m.ReplayAll() self.assertIsNone(stack.state_set(parser.Stack.CREATE, parser.Stack.COMPLETE, 'test')) self.m.VerifyAll() def test_state_bad(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), action=parser.Stack.CREATE, status=parser.Stack.IN_PROGRESS) self.assertEqual((parser.Stack.CREATE, parser.Stack.IN_PROGRESS), stack.state) self.assertRaises(ValueError, stack.state_set, 'baad', parser.Stack.COMPLETE, 'test') self.assertRaises(ValueError, stack.state_set, parser.Stack.CREATE, 'oops', 'test') def test_status_reason(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), status_reason='quux') self.assertEqual('quux', stack.status_reason) stack.state_set(parser.Stack.CREATE, parser.Stack.IN_PROGRESS, 'wibble') self.assertEqual('wibble', stack.status_reason) def test_load_nonexistant_id(self): self.assertRaises(exception.NotFound, parser.Stack.load, None, -1) def test_total_resources_empty(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), status_reason='flimflam') self.assertEqual(0, stack.total_resources()) def test_total_resources_generic(self): tpl = {'Resources': {'A': {'Type': 'GenericResourceType'}}} stack = parser.Stack(self.ctx, 'test_stack', parser.Template(tpl), status_reason='blarg') self.assertEqual(1, stack.total_resources()) def _setup_nested(self, name): nested_tpl = ('{"HeatTemplateFormatVersion" : "2012-12-12",' '"Resources":{' '"A": {"Type": "GenericResourceType"},' '"B": {"Type": "GenericResourceType"}}}') tpl = {'HeatTemplateFormatVersion': "2012-12-12", 'Resources': {'A': {'Type': 'AWS::CloudFormation::Stack', 'Properties': {'TemplateURL': 'http://server.test/nested.json'}}, 'B': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(urlfetch, 'get') urlfetch.get('http://server.test/nested.json').AndReturn(nested_tpl) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'test_stack', parser.Template(tpl), status_reason=name) self.stack.store() self.stack.create() @utils.stack_delete_after def test_total_resources_nested(self): self._setup_nested('zyzzyx') self.assertEqual(4, self.stack.total_resources()) self.assertIsNotNone(self.stack['A'].nested()) self.assertEqual( 2, self.stack['A'].nested().total_resources()) self.assertEqual( 4, self.stack['A'].nested().root_stack.total_resources()) @utils.stack_delete_after def test_root_stack(self): self._setup_nested('toor') self.assertEqual(self.stack, self.stack.root_stack) self.assertIsNotNone(self.stack['A'].nested()) self.assertEqual( self.stack, self.stack['A'].nested().root_stack) @utils.stack_delete_after def test_load_parent_resource(self): self.stack = parser.Stack(self.ctx, 'load_parent_resource', parser.Template({})) self.stack.store() stack = db_api.stack_get(self.ctx, self.stack.id) t = template.Template.load(self.ctx, stack.raw_template_id) self.m.StubOutWithMock(template.Template, 'load') template.Template.load(self.ctx, stack.raw_template_id).AndReturn(t) env = environment.Environment(stack.parameters) self.m.StubOutWithMock(environment, 'Environment') environment.Environment(stack.parameters).AndReturn(env) self.m.StubOutWithMock(parser.Stack, '__init__') parser.Stack.__init__(self.ctx, stack.name, t, env, stack.id, stack.action, stack.status, stack.status_reason, stack.timeout, True, stack.disable_rollback, 'parent', owner_id=None, stack_user_project_id=None, created_time=IgnoreArg(), updated_time=None, user_creds_id=stack.user_creds_id, tenant_id='test_tenant_id', validate_parameters=False) self.m.ReplayAll() parser.Stack.load(self.ctx, stack_id=self.stack.id, parent_resource='parent') self.m.VerifyAll() # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the self.stack is properly cleaned up @utils.stack_delete_after def test_identifier(self): self.stack = parser.Stack(self.ctx, 'identifier_test', parser.Template({})) self.stack.store() identifier = self.stack.identifier() self.assertEqual(self.stack.tenant_id, identifier.tenant) self.assertEqual('identifier_test', identifier.stack_name) self.assertTrue(identifier.stack_id) self.assertFalse(identifier.path) @utils.stack_delete_after def test_get_stack_abandon_data(self): tpl = {'Resources': {'A': {'Type': 'GenericResourceType'}, 'B': {'Type': 'GenericResourceType'}}} resources = '''{"A": {"status": "COMPLETE", "name": "A", "resource_data": {}, "resource_id": null, "action": "INIT", "type": "GenericResourceType", "metadata": {}}, "B": {"status": "COMPLETE", "name": "B", "resource_data": {}, "resource_id": null, "action": "INIT", "type": "GenericResourceType", "metadata": {}}}''' self.stack = parser.Stack(self.ctx, 'stack_details_test', parser.Template(tpl)) self.stack.store() info = self.stack.get_abandon_data() self.assertIsNone(info['action']) self.assertIn('id', info) self.assertEqual('stack_details_test', info['name']) self.assertEqual(json.loads(resources), info['resources']) self.assertIsNone(info['status']) self.assertEqual(tpl, info['template']) @utils.stack_delete_after def test_set_stack_res_deletion_policy(self): tpl = {'Resources': {'A': {'Type': 'GenericResourceType'}, 'B': {'Type': 'GenericResourceType'}}} stack = parser.Stack(self.ctx, 'stack_details_test', parser.Template(tpl)) stack.store() stack.set_deletion_policy(resource.RETAIN) self.assertEqual(resource.RETAIN, stack.resources['A'].t['DeletionPolicy']) self.assertEqual(resource.RETAIN, stack.resources['B'].t['DeletionPolicy']) @utils.stack_delete_after def test_set_param_id(self): self.stack = parser.Stack(self.ctx, 'param_arn_test', parser.Template({})) exp_prefix = ('arn:openstack:heat::test_tenant_id' ':stacks/param_arn_test/') self.assertEqual(self.stack.parameters['AWS::StackId'], exp_prefix + 'None') self.stack.store() identifier = self.stack.identifier() self.assertEqual(self.stack.parameters['AWS::StackId'], exp_prefix + self.stack.id) self.assertEqual(self.stack.parameters['AWS::StackId'], identifier.arn()) self.m.VerifyAll() @utils.stack_delete_after def test_set_param_id_update(self): tmpl = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Metadata': {'Bar': {'Ref': 'AWS::StackId'}}, 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_stack_arn_test', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) stack_arn = self.stack.parameters['AWS::StackId'] tmpl2 = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Metadata': {'Bar': {'Ref': 'AWS::StackId'}}, 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('xyz', self.stack['AResource'].properties['Foo']) self.assertEqual(stack_arn, self.stack['AResource'].metadata['Bar']) @utils.stack_delete_after def test_load_param_id(self): self.stack = parser.Stack(self.ctx, 'param_load_arn_test', parser.Template({})) self.stack.store() identifier = self.stack.identifier() self.assertEqual(self.stack.parameters['AWS::StackId'], identifier.arn()) newstack = parser.Stack.load(self.ctx, stack_id=self.stack.id) self.assertEqual(identifier.arn(), newstack.parameters['AWS::StackId']) @utils.stack_delete_after def test_load_reads_tenant_id(self): self.ctx.tenant_id = 'foobar' self.stack = parser.Stack(self.ctx, 'stack_name', parser.Template({})) self.stack.store() stack_id = self.stack.id self.ctx.tenant_id = None stack = parser.Stack.load(self.ctx, stack_id=stack_id) self.assertEqual('foobar', stack.tenant_id) @utils.stack_delete_after def test_created_time(self): self.stack = parser.Stack(self.ctx, 'creation_time_test', parser.Template({})) self.assertIsNone(self.stack.created_time) self.stack.store() self.assertIsNotNone(self.stack.created_time) @utils.stack_delete_after def test_updated_time(self): self.stack = parser.Stack(self.ctx, 'updated_time_test', parser.Template({})) self.assertIsNone(self.stack.updated_time) self.stack.store() self.stack.create() tmpl = {'Resources': {'R1': {'Type': 'GenericResourceType'}}} newstack = parser.Stack(self.ctx, 'updated_time_test', parser.Template(tmpl)) self.stack.update(newstack) self.assertIsNotNone(self.stack.updated_time) @utils.stack_delete_after def test_access_policy_update(self): tmpl = {'Resources': { 'R1': {'Type': 'GenericResourceType'}, 'Policy': { 'Type': 'OS::Heat::AccessPolicy', 'Properties': { 'AllowedResources': ['R1'], }, }}} self.stack = parser.Stack(self.ctx, 'update_stack_access_policy_test', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': { 'R1': {'Type': 'GenericResourceType'}, 'R2': {'Type': 'GenericResourceType'}, 'Policy': { 'Type': 'OS::Heat::AccessPolicy', 'Properties': { 'AllowedResources': ['R1', 'R2'], }, }}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) @utils.stack_delete_after def test_delete(self): self.stack = parser.Stack(self.ctx, 'delete_test', parser.Template({})) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.stack.delete() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), self.stack.state) @utils.stack_delete_after def test_delete_user_creds(self): self.stack = parser.Stack(self.ctx, 'delete_test', parser.Template({})) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.assertIsNotNone(db_s.user_creds_id) user_creds_id = db_s.user_creds_id db_creds = db_api.user_creds_get(db_s.user_creds_id) self.assertIsNotNone(db_creds) self.stack.delete() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) db_creds = db_api.user_creds_get(user_creds_id) self.assertIsNone(db_creds) del_db_s = db_api.stack_get(self.ctx, stack_id, show_deleted=True) self.assertIsNone(del_db_s.user_creds_id) self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), self.stack.state) @utils.stack_delete_after def test_delete_trust(self): cfg.CONF.set_override('deferred_auth_method', 'trusts') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( FakeKeystoneClient()) self.m.ReplayAll() self.stack = parser.Stack( self.ctx, 'delete_trust', template.Template({})) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.stack.delete() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), self.stack.state) @utils.stack_delete_after def test_delete_trust_backup(self): cfg.CONF.set_override('deferred_auth_method', 'trusts') class FakeKeystoneClientFail(FakeKeystoneClient): def delete_trust(self, trust_id): raise Exception("Shouldn't delete") self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( FakeKeystoneClientFail()) self.m.ReplayAll() self.stack = parser.Stack( self.ctx, 'delete_trust', template.Template({})) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.stack.delete(backup=True) db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) self.assertEqual(self.stack.state, (parser.Stack.DELETE, parser.Stack.COMPLETE)) @utils.stack_delete_after def test_delete_trust_fail(self): cfg.CONF.set_override('deferred_auth_method', 'trusts') class FakeKeystoneClientFail(FakeKeystoneClient): def delete_trust(self, trust_id): raise kc_exceptions.Forbidden("Denied!") self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( FakeKeystoneClientFail()) self.m.ReplayAll() self.stack = parser.Stack( self.ctx, 'delete_trust', template.Template({})) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.stack.delete() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), self.stack.state) self.assertIn('Error deleting trust', self.stack.status_reason) @utils.stack_delete_after def test_suspend_resume(self): self.m.ReplayAll() tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'suspend_test', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) self.stack.resume() self.assertEqual((self.stack.RESUME, self.stack.COMPLETE), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_suspend_stack_suspended_ok(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'suspend_test', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) # unexpected to call Resource.suspend self.m.StubOutWithMock(generic_rsrc.GenericResource, 'suspend') self.m.ReplayAll() self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_resume_stack_resumeed_ok(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'suspend_test', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) self.stack.resume() self.assertEqual((self.stack.RESUME, self.stack.COMPLETE), self.stack.state) # unexpected to call Resource.resume self.m.StubOutWithMock(generic_rsrc.GenericResource, 'resume') self.m.ReplayAll() self.stack.resume() self.assertEqual((self.stack.RESUME, self.stack.COMPLETE), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_suspend_fail(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_suspend') exc = Exception('foo') generic_rsrc.GenericResource.handle_suspend().AndRaise(exc) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'suspend_test_fail', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.FAILED), self.stack.state) self.assertEqual('Resource SUSPEND failed: Exception: foo', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after def test_resume_fail(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_resume') generic_rsrc.GenericResource.handle_resume().AndRaise(Exception('foo')) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'resume_test_fail', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) self.stack.resume() self.assertEqual((self.stack.RESUME, self.stack.FAILED), self.stack.state) self.assertEqual('Resource RESUME failed: Exception: foo', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after def test_suspend_timeout(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_suspend') exc = scheduler.Timeout('foo', 0) generic_rsrc.GenericResource.handle_suspend().AndRaise(exc) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'suspend_test_fail_timeout', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.FAILED), self.stack.state) self.assertEqual('Suspend timed out', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after def test_resume_timeout(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_resume') exc = scheduler.Timeout('foo', 0) generic_rsrc.GenericResource.handle_resume().AndRaise(exc) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'resume_test_fail_timeout', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.suspend() self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), self.stack.state) self.stack.resume() self.assertEqual((self.stack.RESUME, self.stack.FAILED), self.stack.state) self.assertEqual('Resume timed out', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after def test_delete_rollback(self): self.stack = parser.Stack(self.ctx, 'delete_rollback_test', parser.Template({}), disable_rollback=False) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.stack.delete(action=self.stack.ROLLBACK) db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) @utils.stack_delete_after def test_delete_badaction(self): self.stack = parser.Stack(self.ctx, 'delete_badaction_test', parser.Template({})) stack_id = self.stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.stack.delete(action="wibble") db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), self.stack.state) @utils.stack_delete_after def test_adopt_stack(self): adopt_data = '''{ "action": "CREATE", "status": "COMPLETE", "name": "my-test-stack-name", "resources": { "AResource": { "status": "COMPLETE", "name": "AResource", "resource_data": {}, "metadata": {}, "resource_id": "test-res-id", "action": "CREATE", "type": "GenericResourceType" } } }''' tmpl = { 'Resources': {'AResource': {'Type': 'GenericResourceType'}}, 'Outputs': {'TestOutput': {'Value': { 'Fn::GetAtt': ['AResource', 'Foo']}} } } self.stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(tmpl), adopt_stack_data=json.loads(adopt_data)) self.stack.store() self.stack.adopt() res = self.stack['AResource'] self.assertEqual(u'test-res-id', res.resource_id) self.assertEqual('AResource', res.name) self.assertEqual('COMPLETE', res.status) self.assertEqual('ADOPT', res.action) self.assertEqual((self.stack.ADOPT, self.stack.COMPLETE), self.stack.state) self.assertEqual('AResource', self.stack.output('TestOutput')) @utils.stack_delete_after def test_adopt_stack_fails(self): adopt_data = '''{ "action": "CREATE", "status": "COMPLETE", "name": "my-test-stack-name", "resources": {} }''' tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, } }) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', tmpl, adopt_stack_data=json.loads(adopt_data)) self.stack.store() self.stack.adopt() self.assertEqual((self.stack.ADOPT, self.stack.FAILED), self.stack.state) expected = ('Resource ADOPT failed: Exception: Resource ID was not' ' provided.') self.assertEqual(expected, self.stack.status_reason) @utils.stack_delete_after def test_adopt_stack_rollback(self): adopt_data = '''{ "name": "my-test-stack-name", "resources": {} }''' tmpl = template.Template({ 'Resources': { 'foo': {'Type': 'GenericResourceType'}, } }) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', tmpl, disable_rollback=False, adopt_stack_data=json.loads(adopt_data)) self.stack.store() self.stack.adopt() self.assertEqual((self.stack.ROLLBACK, self.stack.COMPLETE), self.stack.state) @utils.stack_delete_after def test_update_badstate(self): self.stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), action=parser.Stack.CREATE, status=parser.Stack.FAILED) self.stack.store() self.assertEqual((parser.Stack.CREATE, parser.Stack.FAILED), self.stack.state) self.stack.update(mock.Mock()) self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), self.stack.state) @utils.stack_delete_after def test_resource_by_refid(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'resource_by_refid_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertIn('AResource', self.stack) rsrc = self.stack['AResource'] rsrc.resource_id_set('aaaa') self.assertIsNotNone(resource) for action, status in ( (rsrc.INIT, rsrc.COMPLETE), (rsrc.CREATE, rsrc.IN_PROGRESS), (rsrc.CREATE, rsrc.COMPLETE), (rsrc.RESUME, rsrc.IN_PROGRESS), (rsrc.RESUME, rsrc.COMPLETE), (rsrc.UPDATE, rsrc.IN_PROGRESS), (rsrc.UPDATE, rsrc.COMPLETE)): rsrc.state_set(action, status) self.assertEqual(rsrc, self.stack.resource_by_refid('aaaa')) rsrc.state_set(rsrc.DELETE, rsrc.IN_PROGRESS) try: self.assertIsNone(self.stack.resource_by_refid('aaaa')) self.assertIsNone(self.stack.resource_by_refid('bbbb')) finally: rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE) @utils.stack_delete_after def test_update_add(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertIn('BResource', self.stack) @utils.stack_delete_after def test_update_remove(self): tmpl = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertNotIn('BResource', self.stack) @utils.stack_delete_after def test_update_description(self): tmpl = {'Description': 'ATemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Description': 'BTemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('BTemplate', self.stack.t[self.stack.t.DESCRIPTION]) @utils.stack_delete_after def test_update_timeout(self): tmpl = {'HeatTemplateFormatVersion': '2012-12-12', 'Description': 'ATemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), timeout_mins=60) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'HeatTemplateFormatVersion': '2012-12-12', 'Description': 'ATemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), timeout_mins=30) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual(30, self.stack.timeout_mins) @utils.stack_delete_after def test_update_disable_rollback(self): tmpl = {'Description': 'ATemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Description': 'ATemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=True) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual(True, self.stack.disable_rollback) @utils.stack_delete_after def test_update_modify_ok_replace(self): tmpl = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('xyz', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after def test_update_modify_param_ok_replace(self): tmpl = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'foo': {'Type': 'String'} }, 'Resources': { 'AResource': { 'Type': 'ResourceWithPropsType', 'Properties': {'Foo': {'Ref': 'foo'}} } } } self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'update_template_diff') self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), environment.Environment({'foo': 'abc'})) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl), environment.Environment({'foo': 'xyz'})) def check_props(*args): self.assertEqual('abc', self.stack['AResource'].properties['Foo']) generic_rsrc.ResourceWithProps.update_template_diff( {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}, {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}).WithSideEffects(check_props) \ .AndRaise(resource.UpdateReplace) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('xyz', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after def test_update_modify_update_failed(self): tmpl = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=True) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) res = self.stack['AResource'] res.update_allowed_keys = ('Properties',) res.update_allowed_properties = ('Foo',) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) # patch in a dummy handle_update self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_update') tmpl_diff = {'Properties': {'Foo': 'xyz'}} prop_diff = {'Foo': 'xyz'} generic_rsrc.ResourceWithProps.handle_update( tmpl2['Resources']['AResource'], tmpl_diff, prop_diff).AndRaise(Exception("Foo")) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_update_modify_replace_failed_delete(self): tmpl = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=True) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties # make the update fail deleting the existing resource self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') generic_rsrc.ResourceWithProps.handle_delete().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), self.stack.state) self.m.VerifyAll() # Unset here so destroy() is not stubbed for stack.delete cleanup self.m.UnsetStubs() @utils.stack_delete_after def test_update_modify_replace_failed_create(self): tmpl = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=True) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties # patch in a dummy handle_create making the replace fail creating self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') generic_rsrc.ResourceWithProps.handle_create().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_update_add_failed_create(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) # patch in a dummy handle_create making BResource fail creating self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create') generic_rsrc.GenericResource.handle_create().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), self.stack.state) self.assertIn('BResource', self.stack) # Reload the stack from the DB and prove that it contains the failed # resource (to ensure it will be deleted on stack delete) re_stack = parser.Stack.load(self.ctx, stack_id=self.stack.id) self.assertIn('BResource', re_stack) self.m.VerifyAll() @utils.stack_delete_after def test_update_rollback(self): tmpl = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties # patch in a dummy handle_create making the replace fail when creating # the replacement rsrc self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') generic_rsrc.ResourceWithProps.handle_create().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after def test_update_rollback_fail(self): tmpl = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties # patch in a dummy handle_create making the replace fail when creating # the replacement rsrc, and again on the second call (rollback) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') generic_rsrc.ResourceWithProps.handle_create().AndRaise(Exception) generic_rsrc.ResourceWithProps.handle_delete().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.FAILED), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_update_rollback_add(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) # patch in a dummy handle_create making the replace fail when creating # the replacement rsrc, and succeed on the second call (rollback) self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create') generic_rsrc.GenericResource.handle_create().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) self.assertNotIn('BResource', self.stack) self.m.VerifyAll() @utils.stack_delete_after def test_update_rollback_remove(self): tmpl = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'ResourceWithPropsType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) # patch in a dummy delete making the destroy fail self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') generic_rsrc.ResourceWithProps.handle_delete().AndRaise(Exception) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) self.assertIn('BResource', self.stack) self.m.VerifyAll() # Unset here so delete() is not stubbed for stack.delete cleanup self.m.UnsetStubs() @utils.stack_delete_after def test_update_rollback_replace(self): tmpl = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'foo'}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'bar'}}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) # patch in a dummy delete making the destroy fail self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_delete') generic_rsrc.ResourceWithProps.handle_delete().AndRaise(Exception) generic_rsrc.ResourceWithProps.handle_delete().AndReturn(None) generic_rsrc.ResourceWithProps.handle_delete().AndReturn(None) self.m.ReplayAll() self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) self.m.VerifyAll() # Unset here so delete() is not stubbed for stack.delete cleanup self.m.UnsetStubs() @utils.stack_delete_after def test_update_replace_by_reference(self): ''' assertion: changes in dynamic attributes, due to other resources been updated are not ignored and can cause dependent resources to be updated. ''' tmpl = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} tmpl2 = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'smelly'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.m.ReplayAll() self.stack.store() self.stack.create() self.m.VerifyAll() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.assertEqual('AResource', self.stack['BResource'].properties['Foo']) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'FnGetRefId') generic_rsrc.ResourceWithProps.FnGetRefId().AndReturn( 'AResource') generic_rsrc.ResourceWithProps.FnGetRefId().MultipleTimes().AndReturn( 'inst-007') self.m.ReplayAll() updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('smelly', self.stack['AResource'].properties['Foo']) self.assertEqual('inst-007', self.stack['BResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after def test_update_with_new_resources_with_reference(self): ''' assertion: check, that during update with new resources which one has reference on second, reference will be correct resolved. ''' tmpl = {'Resources': { 'CResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} tmpl2 = {'Resources': { 'CResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}, 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'smelly'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl)) self.m.ReplayAll() self.stack.store() self.stack.create() self.m.VerifyAll() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['CResource'].properties['Foo']) self.assertEqual(1, len(self.stack.resources)) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') generic_rsrc.ResourceWithProps.handle_create().MultipleTimes().\ AndReturn(None) self.m.ReplayAll() updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('smelly', self.stack['AResource'].properties['Foo']) self.assertEqual('AResource', self.stack['BResource'].properties['Foo']) self.assertEqual(3, len(self.stack.resources)) self.m.VerifyAll() @utils.stack_delete_after def test_update_by_reference_and_rollback_1(self): ''' assertion: check that rollback still works with dynamic metadata this test fails the first instance ''' tmpl = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} tmpl2 = {'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'smelly'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.m.ReplayAll() self.stack.store() self.stack.create() self.m.VerifyAll() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.assertEqual('AResource', self.stack['BResource'].properties['Foo']) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'FnGetRefId') self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') # Calls to ResourceWithProps.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties generic_rsrc.ResourceWithProps.FnGetRefId().MultipleTimes().AndReturn( 'AResource') # mock to make the replace fail when creating the replacement resource generic_rsrc.ResourceWithProps.handle_create().AndRaise(Exception) self.m.ReplayAll() updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after def test_update_by_reference_and_rollback_2(self): ''' assertion: check that rollback still works with dynamic metadata this test fails the second instance ''' class ResourceTypeA(generic_rsrc.ResourceWithProps): count = 0 def handle_create(self): ResourceTypeA.count += 1 self.resource_id_set('%s%d' % (self.name, self.count)) resource._register_class('ResourceTypeA', ResourceTypeA) tmpl = {'Resources': { 'AResource': {'Type': 'ResourceTypeA', 'Properties': {'Foo': 'abc'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} tmpl2 = {'Resources': { 'AResource': {'Type': 'ResourceTypeA', 'Properties': {'Foo': 'smelly'}}, 'BResource': {'Type': 'ResourceWithPropsType', 'Properties': { 'Foo': {'Ref': 'AResource'}}}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.m.ReplayAll() self.stack.store() self.stack.create() self.m.VerifyAll() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.assertEqual('AResource1', self.stack['BResource'].properties['Foo']) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') # Calls to ResourceWithProps.handle_update will raise # resource.UpdateReplace because we've not specified the modified # key/property in update_allowed_keys/update_allowed_properties # mock to make the replace fail when creating the second # replacement resource generic_rsrc.ResourceWithProps.handle_create().AndRaise(Exception) self.m.ReplayAll() updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2), disable_rollback=False) self.stack.update(updated_stack) self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.assertEqual('AResource1', self.stack['BResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after def test_update_replace_parameters(self): ''' assertion: changes in static environment parameters are not ignored and can cause dependent resources to be updated. ''' tmpl = {'Parameters': {'AParam': {'Type': 'String'}}, 'Resources': { 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': {'Ref': 'AParam'}}}}} env1 = {'parameters': {'AParam': 'abc'}} env2 = {'parameters': {'AParam': 'smelly'}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), environment.Environment(env1)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('abc', self.stack['AResource'].properties['Foo']) updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl), environment.Environment(env2)) self.stack.update(updated_stack) self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual('smelly', self.stack['AResource'].properties['Foo']) def test_stack_create_timeout(self): self.m.StubOutWithMock(scheduler.DependencyTaskGroup, '__call__') self.m.StubOutWithMock(scheduler, 'wallclock') stack = parser.Stack(self.ctx, 's', parser.Template({})) def dummy_task(): while True: yield start_time = time.time() scheduler.wallclock().AndReturn(start_time) scheduler.wallclock().AndReturn(start_time + 1) scheduler.DependencyTaskGroup.__call__().AndReturn(dummy_task()) scheduler.wallclock().AndReturn(start_time + stack.timeout_secs() + 1) self.m.ReplayAll() stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.FAILED), stack.state) self.assertEqual('Create timed out', stack.status_reason) self.m.VerifyAll() def test_stack_delete_timeout(self): stack = parser.Stack(self.ctx, 'delete_test', parser.Template({})) stack_id = stack.store() db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) self.m.StubOutWithMock(scheduler.DependencyTaskGroup, '__call__') self.m.StubOutWithMock(scheduler, 'wallclock') def dummy_task(): while True: yield start_time = time.time() scheduler.wallclock().AndReturn(start_time) scheduler.wallclock().AndReturn(start_time + 1) scheduler.DependencyTaskGroup.__call__().AndReturn(dummy_task()) scheduler.wallclock().AndReturn(start_time + stack.timeout_secs() + 1) self.m.ReplayAll() stack.delete() self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), stack.state) self.assertEqual('Delete timed out', stack.status_reason) self.m.VerifyAll() def test_stack_delete_resourcefailure(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_delete') exc = Exception('foo') generic_rsrc.GenericResource.handle_delete().AndRaise(exc) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'delete_test_fail', parser.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.stack.delete() self.assertEqual((self.stack.DELETE, self.stack.FAILED), self.stack.state) self.assertEqual('Resource DELETE failed: Exception: foo', self.stack.status_reason) self.m.VerifyAll() def test_stack_name_valid(self): stack = parser.Stack(self.ctx, 's', parser.Template({})) self.assertIsInstance(stack, parser.Stack) stack = parser.Stack(self.ctx, 'stack123', parser.Template({})) self.assertIsInstance(stack, parser.Stack) stack = parser.Stack(self.ctx, 'test.stack', parser.Template({})) self.assertIsInstance(stack, parser.Stack) stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) self.assertIsInstance(stack, parser.Stack) stack = parser.Stack(self.ctx, 'TEST', parser.Template({})) self.assertIsInstance(stack, parser.Stack) stack = parser.Stack(self.ctx, 'test-stack', parser.Template({})) self.assertIsInstance(stack, parser.Stack) def test_stack_name_invalid(self): self.assertRaises(ValueError, parser.Stack, self.ctx, '_foo', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '1bad', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '.kcats', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'test stack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, ' teststack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '^-^', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '\"stack\"', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '1234', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'cat|dog', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '$(foo)', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'test/stack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'test\stack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'test::stack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'test;stack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, 'test~stack', parser.Template({})) self.assertRaises(ValueError, parser.Stack, self.ctx, '#test', parser.Template({})) @utils.stack_delete_after def test_resource_state_get_att(self): tmpl = { 'Resources': {'AResource': {'Type': 'GenericResourceType'}}, 'Outputs': {'TestOutput': {'Value': { 'Fn::GetAtt': ['AResource', 'Foo']}} } } self.stack = parser.Stack(self.ctx, 'resource_state_get_att', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertIn('AResource', self.stack) rsrc = self.stack['AResource'] rsrc.resource_id_set('aaaa') self.assertEqual('AResource', rsrc.FnGetAtt('Foo')) for action, status in ( (rsrc.CREATE, rsrc.IN_PROGRESS), (rsrc.CREATE, rsrc.COMPLETE), (rsrc.SUSPEND, rsrc.IN_PROGRESS), (rsrc.SUSPEND, rsrc.COMPLETE), (rsrc.RESUME, rsrc.IN_PROGRESS), (rsrc.RESUME, rsrc.COMPLETE), (rsrc.UPDATE, rsrc.IN_PROGRESS), (rsrc.UPDATE, rsrc.COMPLETE)): rsrc.state_set(action, status) self.assertEqual('AResource', self.stack.output('TestOutput')) for action, status in ( (rsrc.CREATE, rsrc.FAILED), (rsrc.DELETE, rsrc.IN_PROGRESS), (rsrc.DELETE, rsrc.FAILED), (rsrc.DELETE, rsrc.COMPLETE), (rsrc.UPDATE, rsrc.FAILED)): rsrc.state_set(action, status) self.assertIsNone(self.stack.output('TestOutput')) @utils.stack_delete_after def test_resource_required_by(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType', 'DependsOn': 'AResource'}, 'CResource': {'Type': 'GenericResourceType', 'DependsOn': 'BResource'}, 'DResource': {'Type': 'GenericResourceType', 'DependsOn': 'BResource'}}} self.stack = parser.Stack(self.ctx, 'depends_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) self.assertEqual(['BResource'], self.stack['AResource'].required_by()) self.assertEqual([], self.stack['CResource'].required_by()) required_by = self.stack['BResource'].required_by() self.assertEqual(2, len(required_by)) for r in ['CResource', 'DResource']: self.assertIn(r, required_by) @utils.stack_delete_after def test_resource_multi_required_by(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType'}, 'CResource': {'Type': 'GenericResourceType'}, 'DResource': {'Type': 'GenericResourceType', 'DependsOn': ['AResource', 'BResource', 'CResource']}}} self.stack = parser.Stack(self.ctx, 'depends_test_stack', template.Template(tmpl)) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) for r in ['AResource', 'BResource', 'CResource']: self.assertEqual(['DResource'], self.stack[r].required_by()) @utils.stack_delete_after def test_store_saves_owner(self): """ The owner_id attribute of Store is saved to the database when stored. """ self.stack = parser.Stack( self.ctx, 'owner_stack', template.Template({})) stack_ownee = parser.Stack( self.ctx, 'ownee_stack', template.Template({}), owner_id=self.stack.id) stack_ownee.store() db_stack = db_api.stack_get(self.ctx, stack_ownee.id) self.assertEqual(self.stack.id, db_stack.owner_id) @utils.stack_delete_after def test_store_saves_creds(self): """ A user_creds entry is created on first stack store """ self.stack = parser.Stack( self.ctx, 'creds_stack', template.Template({})) self.stack.store() # The store should've created a user_creds row and set user_creds_id db_stack = db_api.stack_get(self.ctx, self.stack.id) user_creds_id = db_stack.user_creds_id self.assertIsNotNone(user_creds_id) # should've stored the username/password in the context user_creds = db_api.user_creds_get(user_creds_id) self.assertEqual(self.ctx.username, user_creds.get('username')) self.assertEqual(self.ctx.password, user_creds.get('password')) self.assertIsNone(user_creds.get('trust_id')) self.assertIsNone(user_creds.get('trustor_user_id')) # Store again, ID should not change self.stack.store() self.assertEqual(user_creds_id, db_stack.user_creds_id) @utils.stack_delete_after def test_store_saves_creds_trust(self): """ A user_creds entry is created on first stack store """ cfg.CONF.set_override('deferred_auth_method', 'trusts') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().MultipleTimes().AndReturn( FakeKeystoneClient()) self.m.ReplayAll() self.stack = parser.Stack( self.ctx, 'creds_stack', template.Template({})) self.stack.store() # The store should've created a user_creds row and set user_creds_id db_stack = db_api.stack_get(self.ctx, self.stack.id) user_creds_id = db_stack.user_creds_id self.assertIsNotNone(user_creds_id) # should've stored the trust_id and trustor_user_id returned from # FakeKeystoneClient.create_trust_context, username/password should # not have been stored user_creds = db_api.user_creds_get(user_creds_id) self.assertIsNone(user_creds.get('username')) self.assertIsNone(user_creds.get('password')) self.assertEqual('atrust', user_creds.get('trust_id')) self.assertEqual('auser123', user_creds.get('trustor_user_id')) # Store again, ID should not change self.stack.store() self.assertEqual(user_creds_id, db_stack.user_creds_id) @utils.stack_delete_after def test_load_honors_owner(self): """ Loading a stack from the database will set the owner_id of the resultant stack appropriately. """ self.stack = parser.Stack( self.ctx, 'owner_stack', template.Template({})) stack_ownee = parser.Stack( self.ctx, 'ownee_stack', template.Template({}), owner_id=self.stack.id) stack_ownee.store() saved_stack = parser.Stack.load(self.ctx, stack_id=stack_ownee.id) self.assertEqual(self.stack.id, saved_stack.owner_id) @utils.stack_delete_after def test_requires_deferred_auth(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}, 'BResource': {'Type': 'GenericResourceType'}, 'CResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'update_test_stack', template.Template(tmpl), disable_rollback=False) self.assertFalse(self.stack.requires_deferred_auth()) self.stack['CResource'].requires_deferred_auth = True self.assertTrue(self.stack.requires_deferred_auth()) @utils.stack_delete_after def test_stack_user_project_id_default(self): self.stack = parser.Stack(self.ctx, 'user_project_none', template.Template({})) self.stack.store() self.assertIsNone(self.stack.stack_user_project_id) db_stack = db_api.stack_get(self.ctx, self.stack.id) self.assertIsNone(db_stack.stack_user_project_id) @utils.stack_delete_after def test_stack_user_project_id_constructor(self): self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().AndReturn(FakeKeystoneClient()) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'user_project_init', template.Template({}), stack_user_project_id='aproject1234') self.stack.store() self.assertEqual('aproject1234', self.stack.stack_user_project_id) db_stack = db_api.stack_get(self.ctx, self.stack.id) self.assertEqual('aproject1234', db_stack.stack_user_project_id) self.stack.delete() self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), self.stack.state) self.m.VerifyAll() @utils.stack_delete_after def test_stack_user_project_id_delete_fail(self): class FakeKeystoneClientFail(FakeKeystoneClient): def delete_stack_domain_project(self, project_id): raise kc_exceptions.Forbidden("Denied!") self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().AndReturn(FakeKeystoneClientFail()) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'user_project_init', template.Template({}), stack_user_project_id='aproject1234') self.stack.store() self.assertEqual('aproject1234', self.stack.stack_user_project_id) db_stack = db_api.stack_get(self.ctx, self.stack.id) self.assertEqual('aproject1234', db_stack.stack_user_project_id) self.stack.delete() self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), self.stack.state) self.assertIn('Error deleting project', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after def test_stack_user_project_id_setter(self): self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') clients.OpenStackClients.keystone().AndReturn(FakeKeystoneClient()) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'user_project_init', template.Template({})) self.stack.store() self.assertIsNone(self.stack.stack_user_project_id) self.stack.set_stack_user_project_id(project_id='aproject456') self.assertEqual('aproject456', self.stack.stack_user_project_id) db_stack = db_api.stack_get(self.ctx, self.stack.id) self.assertEqual('aproject456', db_stack.stack_user_project_id) self.stack.delete() self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), self.stack.state) self.m.VerifyAll() def test_preview_resources_returns_list_of_resource_previews(self): tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} self.stack = parser.Stack(self.ctx, 'preview_stack', template.Template(tmpl)) res = mock.Mock() res.preview.return_value = 'foo' self.stack._resources = {'r1': res} resources = self.stack.preview_resources() self.assertEqual(['foo'], resources) def test_stack_load_no_param_value_validation(self): ''' Test stack loading with disabled parameter value validation. ''' tmpl = template_format.parse(''' heat_template_version: 2013-05-23 parameters: flavor: type: string description: A flavor. constraints: - custom_constraint: nova.flavor resources: a_resource: type: GenericResourceType ''') # Mock objects so the query for flavors in server.FlavorConstraint # works for stack creation fc = fakes.FakeClient() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(fc) fc.flavors = self.m.CreateMockAnything() flavor = collections.namedtuple("Flavor", ["id", "name"]) flavor.id = "1234" flavor.name = "dummy" fc.flavors.list().AndReturn([flavor]) self.m.ReplayAll() self.stack = parser.Stack(self.ctx, 'stack_with_custom_constraint', template.Template(tmpl), environment.Environment({'flavor': 'dummy'})) self.stack.store() self.stack.create() stack_id = self.stack.id self.m.VerifyAll() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) loaded_stack = parser.Stack.load(self.ctx, stack_id=self.stack.id) self.assertEqual(stack_id, loaded_stack.parameters['OS::stack_id']) # verify that fc.flavors.list() has not been called, i.e. verify that # parameter value validation did not happen and FlavorConstraint was # not invoked self.m.VerifyAll() heat-2014.1.5/heat/tests/test_version_negotiation_middleware.py0000664000567000056700000001275612540642614026022 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. import webob from heat.tests.common import HeatTestCase from heat.api.middleware.version_negotiation import VersionNegotiationFilter class VersionController(object): pass class VersionNegotiationMiddlewareTest(HeatTestCase): def _version_controller_factory(self, conf): return VersionController() def test_match_version_string(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({}) major_version = 1 minor_version = 0 match = version_negotiation._match_version_string( 'v{0}.{1}'.format(major_version, minor_version), request) self.assertTrue(match) self.assertEqual(major_version, request.environ['api.major_version']) self.assertEqual(minor_version, request.environ['api.minor_version']) def test_not_match_version_string(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({}) match = version_negotiation._match_version_string("invalid", request) self.assertFalse(match) def test_return_version_controller_when_request_path_is_version(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({'PATH_INFO': 'versions'}) response = version_negotiation.process_request(request) self.assertIsInstance(response, VersionController) def test_return_version_controller_when_request_path_is_empty(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({'PATH_INFO': '/'}) response = version_negotiation.process_request(request) self.assertIsInstance(response, VersionController) def test_request_path_contains_valid_version(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) major_version = 1 minor_version = 0 request = webob.Request({'PATH_INFO': 'v{0}.{1}/resource'.format(major_version, minor_version)}) response = version_negotiation.process_request(request) self.assertIsNone(response) self.assertEqual(major_version, request.environ['api.major_version']) self.assertEqual(minor_version, request.environ['api.minor_version']) def test_removes_version_from_request_path(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) expected_path = 'resource' request = webob.Request({'PATH_INFO': 'v1.0/{0}'.format(expected_path) }) response = version_negotiation.process_request(request) self.assertIsNone(response) self.assertEqual(expected_path, request.path_info_peek()) def test_request_path_contains_unknown_version(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({'PATH_INFO': 'v2.0/resource'}) response = version_negotiation.process_request(request) self.assertIsInstance(response, VersionController) def test_accept_header_contains_valid_version(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) major_version = 1 minor_version = 0 request = webob.Request({'PATH_INFO': 'resource'}) request.headers['Accept'] = 'application/vnd.openstack.' \ 'orchestration-v{0}.{1}'.format(major_version, minor_version) response = version_negotiation.process_request(request) self.assertIsNone(response) self.assertEqual(major_version, request.environ['api.major_version']) self.assertEqual(minor_version, request.environ['api.minor_version']) def test_accept_header_contains_unknown_version(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({'PATH_INFO': 'resource'}) request.headers['Accept'] = 'application/vnd.openstack.' \ 'orchestration-v2.0' response = version_negotiation.process_request(request) self.assertIsInstance(response, VersionController) def test_no_URI_version_accept_header_contains_invalid_MIME_type(self): version_negotiation = VersionNegotiationFilter( self._version_controller_factory, None, None) request = webob.Request({'PATH_INFO': 'resource'}) request.headers['Accept'] = 'application/invalidMIMEType' response = version_negotiation.process_request(request) self.assertIsInstance(response, webob.exc.HTTPNotFound) heat-2014.1.5/heat/tests/test_api_ec2token.py0000664000567000056700000004753412540642614022105 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. import json from oslo.config import cfg import requests from heat.api.aws import ec2token from heat.api.aws import exception from heat.common.wsgi import Request from heat.openstack.common import importutils from heat.tests.common import HeatTestCase class Ec2TokenTest(HeatTestCase): ''' Tests the Ec2Token middleware ''' def setUp(self): super(Ec2TokenTest, self).setUp() self.m.StubOutWithMock(requests, 'post') def _dummy_GET_request(self, params={}, environ={}): # Mangle the params dict into a query string qs = "&".join(["=".join([k, str(params[k])]) for k in params]) environ.update({'REQUEST_METHOD': 'GET', 'QUERY_STRING': qs}) req = Request(environ) return req def test_conf_get_paste(self): dummy_conf = {'auth_uri': 'http://192.0.2.9/v2.0'} ec2 = ec2token.EC2Token(app=None, conf=dummy_conf) self.assertEqual('http://192.0.2.9/v2.0', ec2._conf_get('auth_uri')) self.assertEqual( 'http://192.0.2.9/v2.0/ec2tokens', ec2._conf_get_keystone_ec2_uri('http://192.0.2.9/v2.0')) def test_conf_get_opts(self): cfg.CONF.set_default('auth_uri', 'http://192.0.2.9/v2.0/', group='ec2authtoken') ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('http://192.0.2.9/v2.0/', ec2._conf_get('auth_uri')) self.assertEqual( 'http://192.0.2.9/v2.0/ec2tokens', ec2._conf_get_keystone_ec2_uri('http://192.0.2.9/v2.0/')) def test_get_signature_param_old(self): params = {'Signature': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_signature(dummy_req)) def test_get_signature_param_new(self): params = {'X-Amz-Signature': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_signature(dummy_req)) def test_get_signature_header_space(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('xyz', ec2._get_signature(dummy_req)) def test_get_signature_header_notlast(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo Credential=foo/bar, ' 'Signature=xyz,' 'SignedHeaders=content-type;host;x-amz-date ')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('xyz', ec2._get_signature(dummy_req)) def test_get_signature_header_nospace(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo Credential=foo/bar,' 'SignedHeaders=content-type;host;x-amz-date,' 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('xyz', ec2._get_signature(dummy_req)) def test_get_access_param_old(self): params = {'AWSAccessKeyId': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_param_new(self): params = {'X-Amz-Credential': 'foo/bar'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_header_space(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_header_nospace(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo Credential=foo/bar,' 'SignedHeaders=content-type;host;x-amz-date,' 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_header_last(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo ' 'SignedHeaders=content-type;host;x-amz-date,' 'Signature=xyz,Credential=foo/bar')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) self.assertEqual('foo', ec2._get_access(dummy_req)) def test_call_x_auth_user(self): req_env = {'HTTP_X_AUTH_USER': 'foo'} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app='xyz', conf={}) self.assertEqual('xyz', ec2.__call__(dummy_req)) def test_call_auth_nosig(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app='xyz', conf={}) self.assertRaises(exception.HeatIncompleteSignatureError, ec2.__call__, dummy_req) def test_call_auth_nouser(self): req_env = {'HTTP_AUTHORIZATION': ('Authorization: foo ' 'SignedHeaders=content-type;host;x-amz-date,' 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app='xyz', conf={}) self.assertRaises(exception.HeatMissingAuthenticationTokenError, ec2.__call__, dummy_req) def test_call_auth_noaccess(self): # If there's no accesskey in params or header, but there is a # Signature, we expect HeatMissingAuthenticationTokenError params = {'Signature': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app='xyz', conf={}) self.assertRaises(exception.HeatMissingAuthenticationTokenError, ec2.__call__, dummy_req) def test_call_x_auth_nouser_x_auth_user(self): req_env = {'HTTP_X_AUTH_USER': 'foo', 'HTTP_AUTHORIZATION': ('Authorization: foo ' 'SignedHeaders=content-type;host;x-amz-date,' 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app='xyz', conf={}) self.assertEqual('xyz', ec2.__call__(dummy_req)) def _stub_http_connection(self, headers={}, params={}, response=None, req_url='http://123:5000/v2.0/ec2tokens'): class DummyHTTPResponse(object): text = response def json(self): return json.loads(self.text) body_hash = ('e3b0c44298fc1c149afbf4c8996fb9' '2427ae41e4649b934ca495991b7852b855') req_creds = json.dumps({"ec2Credentials": {"access": "foo", "headers": headers, "host": "heat:8000", "verb": "GET", "params": params, "signature": "xyz", "path": "/v1", "body_hash": body_hash}}) req_headers = {'Content-Type': 'application/json'} requests.post(req_url, data=req_creds, headers=req_headers).AndReturn(DummyHTTPResponse()) def test_call_ok(self): dummy_conf = {'auth_uri': 'http://123:5000/v2.0'} ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) auth_str = ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz') req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1', 'HTTP_AUTHORIZATION': auth_str} dummy_req = self._dummy_GET_request(environ=req_env) ok_resp = json.dumps({'access': {'token': { 'id': 123, 'tenant': {'name': 'tenant', 'id': 'abcd1234'}}}}) self._stub_http_connection(headers={'Authorization': auth_str}, response=ok_resp) self.m.ReplayAll() self.assertEqual('woot', ec2.__call__(dummy_req)) self.assertEqual('tenant', dummy_req.headers['X-Tenant-Name']) self.assertEqual('abcd1234', dummy_req.headers['X-Tenant-Id']) self.m.VerifyAll() def test_call_ok_roles(self): dummy_conf = {'auth_uri': 'http://123:5000/v2.0'} ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) auth_str = ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz') req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1', 'HTTP_AUTHORIZATION': auth_str} dummy_req = self._dummy_GET_request(environ=req_env) ok_resp = json.dumps({'access': { 'token': { 'id': 123, 'tenant': {'name': 'tenant', 'id': 'abcd1234'} }, 'metadata': {'roles': ['aa', 'bb', 'cc']}}}) self._stub_http_connection(headers={'Authorization': auth_str}, response=ok_resp) self.m.ReplayAll() self.assertEqual('woot', ec2.__call__(dummy_req)) self.assertEqual('aa,bb,cc', dummy_req.headers['X-Roles']) self.m.VerifyAll() def test_call_err_tokenid(self): dummy_conf = {'auth_uri': 'http://123:5000/v2.0/'} ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) auth_str = ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz') req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1', 'HTTP_AUTHORIZATION': auth_str} dummy_req = self._dummy_GET_request(environ=req_env) err_msg = "EC2 access key not found." err_resp = json.dumps({'error': {'message': err_msg}}) self._stub_http_connection(headers={'Authorization': auth_str}, response=err_resp) self.m.ReplayAll() self.assertRaises(exception.HeatInvalidClientTokenIdError, ec2.__call__, dummy_req) self.m.VerifyAll() def test_call_err_signature(self): dummy_conf = {'auth_uri': 'http://123:5000/v2.0'} ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) auth_str = ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz') req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1', 'HTTP_AUTHORIZATION': auth_str} dummy_req = self._dummy_GET_request(environ=req_env) err_msg = "EC2 signature not supplied." err_resp = json.dumps({'error': {'message': err_msg}}) self._stub_http_connection(headers={'Authorization': auth_str}, response=err_resp) self.m.ReplayAll() self.assertRaises(exception.HeatSignatureError, ec2.__call__, dummy_req) self.m.VerifyAll() def test_call_err_denied(self): dummy_conf = {'auth_uri': 'http://123:5000/v2.0'} ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) auth_str = ('Authorization: foo Credential=foo/bar, ' 'SignedHeaders=content-type;host;x-amz-date, ' 'Signature=xyz') req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1', 'HTTP_AUTHORIZATION': auth_str} dummy_req = self._dummy_GET_request(environ=req_env) err_resp = json.dumps({}) self._stub_http_connection(headers={'Authorization': auth_str}, response=err_resp) self.m.ReplayAll() self.assertRaises(exception.HeatAccessDeniedError, ec2.__call__, dummy_req) self.m.VerifyAll() def test_call_ok_v2(self): dummy_conf = {'auth_uri': 'http://123:5000/v2.0'} ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) ok_resp = json.dumps({'access': {'metadata': {}, 'token': { 'id': 123, 'tenant': {'name': 'tenant', 'id': 'abcd1234'}}}}) self._stub_http_connection(response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() def test_call_ok_multicloud(self): dummy_conf = { 'allowed_auth_uris': [ 'http://123:5000/v2.0', 'http://456:5000/v2.0'], 'multi_cloud': True } ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) ok_resp = json.dumps({'access': {'metadata': {}, 'token': { 'id': 123, 'tenant': {'name': 'tenant', 'id': 'abcd1234'}}}}) err_msg = "EC2 access key not found." err_resp = json.dumps({'error': {'message': err_msg}}) # first request fails self._stub_http_connection( req_url='http://123:5000/v2.0/ec2tokens', response=err_resp, params={'AWSAccessKeyId': 'foo'}) # second request passes self._stub_http_connection( req_url='http://456:5000/v2.0/ec2tokens', response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() def test_call_err_multicloud(self): dummy_conf = { 'allowed_auth_uris': [ 'http://123:5000/v2.0', 'http://456:5000/v2.0'], 'multi_cloud': True } ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) err_resp1 = json.dumps({}) err_msg2 = "EC2 access key not found." err_resp2 = json.dumps({'error': {'message': err_msg2}}) # first request fails with HeatAccessDeniedError self._stub_http_connection( req_url='http://123:5000/v2.0/ec2tokens', response=err_resp1, params={'AWSAccessKeyId': 'foo'}) # second request fails with HeatInvalidClientTokenIdError self._stub_http_connection( req_url='http://456:5000/v2.0/ec2tokens', response=err_resp2, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() # raised error matches last failure self.assertRaises(exception.HeatInvalidClientTokenIdError, ec2.__call__, dummy_req) self.m.VerifyAll() def test_call_err_multicloud_none_allowed(self): dummy_conf = { 'allowed_auth_uris': [], 'multi_cloud': True } ec2 = ec2token.EC2Token(app='woot', conf=dummy_conf) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) self.m.ReplayAll() self.assertRaises(exception.HeatAccessDeniedError, ec2.__call__, dummy_req) self.m.VerifyAll() def test_call_badconf_no_authuri(self): ec2 = ec2token.EC2Token(app='woot', conf={}) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) self.m.ReplayAll() ex = self.assertRaises(exception.HeatInternalFailureError, ec2.__call__, dummy_req) self.assertEqual('Service misconfigured', str(ex)) self.m.VerifyAll() def test_call_ok_auth_uri_ec2authtoken(self): dummy_url = 'http://123:5000/v2.0' cfg.CONF.set_default('auth_uri', dummy_url, group='ec2authtoken') ec2 = ec2token.EC2Token(app='woot', conf={}) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) ok_resp = json.dumps({'access': {'metadata': {}, 'token': { 'id': 123, 'tenant': {'name': 'tenant', 'id': 'abcd1234'}}}}) self._stub_http_connection(response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() def test_call_ok_auth_uri_ks_authtoken(self): # Import auth_token to have keystone_authtoken settings setup. importutils.import_module('keystoneclient.middleware.auth_token') dummy_url = 'http://123:5000/v2.0' cfg.CONF.set_override('auth_uri', dummy_url, group='keystone_authtoken') ec2 = ec2token.EC2Token(app='woot', conf={}) params = {'AWSAccessKeyId': 'foo', 'Signature': 'xyz'} req_env = {'SERVER_NAME': 'heat', 'SERVER_PORT': '8000', 'PATH_INFO': '/v1'} dummy_req = self._dummy_GET_request(params, req_env) ok_resp = json.dumps({'access': {'metadata': {}, 'token': { 'id': 123, 'tenant': {'name': 'tenant', 'id': 'abcd1234'}}}}) self._stub_http_connection(response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_neutron_security_group.py0000664000567000056700000007130712540642614024372 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. from neutronclient.common.exceptions import NeutronClientException from neutronclient.v2_0 import client as neutronclient from novaclient.v1_1 import security_group_rules as nova_sgr from novaclient.v1_1 import security_groups as nova_sg from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import parser from heat.engine import scheduler from heat.tests.common import HeatTestCase from heat.tests.fakes import FakeKeystoneClient from heat.tests import utils from heat.tests.v1_1 import fakes class SecurityGroupTest(HeatTestCase): test_template = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: OS::Neutron::SecurityGroup Properties: description: HTTP and SSH access rules: - port_range_min: 22 port_range_max: 22 remote_ip_prefix: 0.0.0.0/0 protocol: tcp - port_range_min: 80 port_range_max: 80 protocol: tcp remote_ip_prefix: 0.0.0.0/0 - remote_mode: remote_group_id remote_group_id: wwww protocol: tcp - direction: egress port_range_min: 22 port_range_max: 22 protocol: tcp remote_ip_prefix: 10.0.1.0/24 - direction: egress remote_mode: remote_group_id remote_group_id: xxxx - direction: egress remote_mode: remote_group_id ''' test_template_update = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: OS::Neutron::SecurityGroup Properties: description: SSH access for private network name: myrules rules: - port_range_min: 22 port_range_max: 22 remote_ip_prefix: 10.0.0.10/24 protocol: tcp ''' test_template_validate = ''' HeatTemplateFormatVersion: '2012-12-12' Resources: the_sg: Type: OS::Neutron::SecurityGroup Properties: name: default ''' def setUp(self): super(SecurityGroupTest, self).setUp() self.fc = fakes.FakeClient() self.m.StubOutWithMock(clients.OpenStackClients, 'nova') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') self.m.StubOutWithMock(nova_sgr.SecurityGroupRuleManager, 'create') self.m.StubOutWithMock(nova_sgr.SecurityGroupRuleManager, 'delete') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'create') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'delete') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'get') self.m.StubOutWithMock(nova_sg.SecurityGroupManager, 'list') utils.setup_dummy_db() self.m.StubOutWithMock(neutronclient.Client, 'create_security_group') self.m.StubOutWithMock( neutronclient.Client, 'create_security_group_rule') self.m.StubOutWithMock(neutronclient.Client, 'show_security_group') self.m.StubOutWithMock( neutronclient.Client, 'delete_security_group_rule') self.m.StubOutWithMock(neutronclient.Client, 'delete_security_group') self.m.StubOutWithMock(neutronclient.Client, 'update_security_group') def create_stack(self, template): t = template_format.parse(template) self.stack = self.parse_stack(t) self.assertIsNone(self.stack.create()) return self.stack def parse_stack(self, t): stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, tmpl) stack.store() return stack def assertResourceState(self, rsrc, ref_id, metadata={}): self.assertIsNone(rsrc.validate()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual(ref_id, rsrc.FnGetRefId()) self.assertEqual(metadata, dict(rsrc.metadata)) @utils.stack_delete_after def test_security_group(self): show_created = {'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'sc1', 'description': '', 'security_group_rules': [{ 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'bbbb', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '80', 'id': 'cccc', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '80' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': None, 'id': 'dddd', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }, { 'direction': 'egress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'eeee', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'egress', 'protocol': None, 'port_range_max': None, 'id': 'ffff', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }, { 'direction': 'egress', 'protocol': None, 'port_range_max': None, 'id': 'gggg', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': 'aaaa', 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }], 'id': 'aaaa'} } #create script clients.OpenStackClients.keystone().AndReturn( FakeKeystoneClient()) sg_name = utils.PhysName('test_stack', 'the_sg') neutronclient.Client.create_security_group({ 'security_group': { 'name': sg_name, 'description': 'HTTP and SSH access' } }).AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': sg_name, 'description': 'HTTP and SSH access', 'security_group_rules': [{ "direction": "egress", "ethertype": "IPv4", "id": "aaaa-1", "port_range_max": None, "port_range_min": None, "protocol": None, "remote_group_id": None, "remote_ip_prefix": None, "security_group_id": "aaaa", "tenant_id": "f18ca530cc05425e8bac0a5ff92f7e88" }, { "direction": "egress", "ethertype": "IPv6", "id": "aaaa-2", "port_range_max": None, "port_range_min": None, "protocol": None, "remote_group_id": None, "remote_ip_prefix": None, "security_group_id": "aaaa", "tenant_id": "f18ca530cc05425e8bac0a5ff92f7e88" }], 'id': 'aaaa' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'bbbb' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '80', 'ethertype': 'IPv4', 'port_range_max': '80', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '80', 'ethertype': 'IPv4', 'port_range_max': '80', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'cccc' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'dddd' } }) neutronclient.Client.show_security_group('aaaa').AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': sg_name, 'description': 'HTTP and SSH access', 'security_group_rules': [{ "direction": "egress", "ethertype": "IPv4", "id": "aaaa-1", "port_range_max": None, "port_range_min": None, "protocol": None, "remote_group_id": None, "remote_ip_prefix": None, "security_group_id": "aaaa", "tenant_id": "f18ca530cc05425e8bac0a5ff92f7e88" }, { "direction": "egress", "ethertype": "IPv6", "id": "aaaa-2", "port_range_max": None, "port_range_min": None, "protocol": None, "remote_group_id": None, "remote_ip_prefix": None, "security_group_id": "aaaa", "tenant_id": "f18ca530cc05425e8bac0a5ff92f7e88" }], 'id': 'aaaa' } }) neutronclient.Client.delete_security_group_rule('aaaa-1').AndReturn( None) neutronclient.Client.delete_security_group_rule('aaaa-2').AndReturn( None) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'eeee' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa', 'id': 'ffff' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'aaaa', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'aaaa', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa', 'id': 'gggg' } }) # update script neutronclient.Client.update_security_group( 'aaaa', {'security_group': { 'description': 'SSH access for private network', 'name': 'myrules'}} ).AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'myrules', 'description': 'SSH access for private network', 'security_group_rules': [], 'id': 'aaaa' } }) neutronclient.Client.show_security_group('aaaa').AndReturn( show_created) neutronclient.Client.delete_security_group_rule('bbbb').AndReturn(None) neutronclient.Client.delete_security_group_rule('cccc').AndReturn(None) neutronclient.Client.delete_security_group_rule('dddd').AndReturn(None) neutronclient.Client.delete_security_group_rule('eeee').AndReturn(None) neutronclient.Client.delete_security_group_rule('ffff').AndReturn(None) neutronclient.Client.delete_security_group_rule('gggg').AndReturn(None) neutronclient.Client.show_security_group('aaaa').AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'sc1', 'description': '', 'security_group_rules': [], 'id': 'aaaa' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa', 'id': 'hhhh' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'ethertype': 'IPv6', 'security_group_id': 'aaaa', } }).AndReturn({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv6', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa', 'id': 'iiii' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.0.10/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndReturn({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.0.10/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa', 'id': 'jjjj' } }) # delete script neutronclient.Client.show_security_group('aaaa').AndReturn( show_created) neutronclient.Client.delete_security_group_rule('bbbb').AndReturn(None) neutronclient.Client.delete_security_group_rule('cccc').AndReturn(None) neutronclient.Client.delete_security_group_rule('dddd').AndReturn(None) neutronclient.Client.delete_security_group_rule('eeee').AndReturn(None) neutronclient.Client.delete_security_group_rule('ffff').AndReturn(None) neutronclient.Client.delete_security_group_rule('gggg').AndReturn(None) neutronclient.Client.delete_security_group('aaaa').AndReturn(None) self.m.ReplayAll() stack = self.create_stack(self.test_template) sg = stack['the_sg'] self.assertResourceState(sg, 'aaaa') updated_tmpl = template_format.parse(self.test_template_update) updated_stack = utils.parse_stack(updated_tmpl) stack.update(updated_stack) stack.delete() self.m.VerifyAll() @utils.stack_delete_after def test_security_group_exception(self): #create script clients.OpenStackClients.keystone().AndReturn( FakeKeystoneClient()) sg_name = utils.PhysName('test_stack', 'the_sg') neutronclient.Client.create_security_group({ 'security_group': { 'name': sg_name, 'description': 'HTTP and SSH access' } }).AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': sg_name, 'description': 'HTTP and SSH access', 'security_group_rules': [], 'id': 'aaaa' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'port_range_min': '80', 'ethertype': 'IPv4', 'port_range_max': '80', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'ingress', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.show_security_group('aaaa').AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': sg_name, 'description': 'HTTP and SSH access', 'security_group_rules': [], 'id': 'aaaa' } }) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'port_range_min': '22', 'ethertype': 'IPv4', 'port_range_max': '22', 'protocol': 'tcp', 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'xxxx', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) neutronclient.Client.create_security_group_rule({ 'security_group_rule': { 'direction': 'egress', 'remote_group_id': 'aaaa', 'remote_ip_prefix': None, 'port_range_min': None, 'ethertype': 'IPv4', 'port_range_max': None, 'protocol': None, 'security_group_id': 'aaaa' } }).AndRaise( NeutronClientException(status_code=409)) # delete script neutronclient.Client.show_security_group('aaaa').AndReturn({ 'security_group': { 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'name': 'sc1', 'description': '', 'security_group_rules': [{ 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'bbbb', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': '80', 'id': 'cccc', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '80' }, { 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': None, 'id': 'dddd', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': 'wwww', 'remote_ip_prefix': None, 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }, { 'direction': 'egress', 'protocol': 'tcp', 'port_range_max': '22', 'id': 'eeee', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': '10.0.1.0/24', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': '22' }, { 'direction': 'egress', 'protocol': None, 'port_range_max': None, 'id': 'ffff', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': 'xxxx', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }, { 'direction': 'egress', 'protocol': None, 'port_range_max': None, 'id': 'gggg', 'ethertype': 'IPv4', 'security_group_id': 'aaaa', 'remote_group_id': None, 'remote_ip_prefix': 'aaaa', 'tenant_id': 'f18ca530cc05425e8bac0a5ff92f7e88', 'port_range_min': None }], 'id': 'aaaa'}}) neutronclient.Client.delete_security_group_rule('bbbb').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('cccc').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('dddd').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('eeee').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('ffff').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group_rule('gggg').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.delete_security_group('aaaa').AndRaise( NeutronClientException(status_code=404)) neutronclient.Client.show_security_group('aaaa').AndRaise( NeutronClientException(status_code=404)) self.m.ReplayAll() stack = self.create_stack(self.test_template) sg = stack['the_sg'] self.assertResourceState(sg, 'aaaa') scheduler.TaskRunner(sg.delete)() sg.state_set(sg.CREATE, sg.COMPLETE, 'to delete again') sg.resource_id = 'aaaa' stack.delete() self.m.VerifyAll() @utils.stack_delete_after def test_security_group_validate(self): stack = self.create_stack(self.test_template_validate) sg = stack['the_sg'] ex = self.assertRaises(exception.StackValidationFailed, sg.validate) self.assertEqual( 'Security groups cannot be assigned the name "default".', ex.message) heat-2014.1.5/heat/tests/test_iso8601_utils.py0000664000567000056700000000423512540642614022062 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. from heat.common import timeutils as util from heat.tests.common import HeatTestCase from heat.tests import utils class ISO8601UtilityTest(HeatTestCase): def setUp(self): super(ISO8601UtilityTest, self).setUp() utils.setup_dummy_db() def test_valid_durations(self): self.assertEqual(0, util.parse_isoduration('PT')) self.assertEqual(3600, util.parse_isoduration('PT1H')) self.assertEqual(120, util.parse_isoduration('PT2M')) self.assertEqual(3, util.parse_isoduration('PT3S')) self.assertEqual(3900, util.parse_isoduration('PT1H5M')) self.assertEqual(3605, util.parse_isoduration('PT1H5S')) self.assertEqual(303, util.parse_isoduration('PT5M3S')) self.assertEqual(3903, util.parse_isoduration('PT1H5M3S')) self.assertEqual(24 * 3600, util.parse_isoduration('PT24H')) def test_invalid_durations(self): self.assertRaises(ValueError, util.parse_isoduration, 'P1Y') self.assertRaises(ValueError, util.parse_isoduration, 'P1DT12H') self.assertRaises(ValueError, util.parse_isoduration, 'PT1Y1D') self.assertRaises(ValueError, util.parse_isoduration, 'PTAH1M0S') self.assertRaises(ValueError, util.parse_isoduration, 'PT1HBM0S') self.assertRaises(ValueError, util.parse_isoduration, 'PT1H1MCS') self.assertRaises(ValueError, util.parse_isoduration, 'PT1H1H') self.assertRaises(ValueError, util.parse_isoduration, 'PT1MM') self.assertRaises(ValueError, util.parse_isoduration, 'PT1S0S') self.assertRaises(ValueError, util.parse_isoduration, 'ABCDEFGH') heat-2014.1.5/heat/tests/test_api_openstack_v1_views_stacks_view_builder.py0000664000567000056700000001614012540642614030302 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. import mock from heat.api.openstack.v1.views import stacks_view from heat.common import identifier from heat.tests.common import HeatTestCase class TestFormatStack(HeatTestCase): def setUp(self): super(TestFormatStack, self).setUp() self.request = mock.Mock() def test_doesnt_include_stack_action(self): stack = {'stack_action': 'CREATE'} result = stacks_view.format_stack(self.request, stack) self.assertEqual({}, result) def test_merges_stack_action_and_status(self): stack = {'stack_action': 'CREATE', 'stack_status': 'COMPLETE'} result = stacks_view.format_stack(self.request, stack) self.assertIn('stack_status', result) self.assertEqual('CREATE_COMPLETE', result['stack_status']) def test_include_stack_status_with_no_action(self): stack = {'stack_status': 'COMPLETE'} result = stacks_view.format_stack(self.request, stack) self.assertIn('stack_status', result) self.assertEqual('COMPLETE', result['stack_status']) @mock.patch.object(stacks_view, 'util') def test_replace_stack_identity_with_id_and_links(self, mock_util): mock_util.make_link.return_value = 'blah' stack = {'stack_identity': {'stack_id': 'foo'}} result = stacks_view.format_stack(self.request, stack) self.assertIn('id', result) self.assertNotIn('stack_identity', result) self.assertEqual('foo', result['id']) self.assertIn('links', result) self.assertEqual(['blah'], result['links']) @mock.patch.object(stacks_view, 'util', new=mock.Mock()) def test_doesnt_add_project_by_default(self): stack = {'stack_identity': {'stack_id': 'foo', 'tenant': 'bar'}} result = stacks_view.format_stack(self.request, stack, None) self.assertNotIn('project', result) @mock.patch.object(stacks_view, 'util', new=mock.Mock()) def test_doesnt_add_project_if_tenant_safe(self): stack = {'stack_identity': {'stack_id': 'foo', 'tenant': 'bar'}} result = stacks_view.format_stack(self.request, stack, None, tenant_safe=True) self.assertNotIn('project', result) @mock.patch.object(stacks_view, 'util', new=mock.Mock()) def test_adds_project_if_not_tenant_safe(self): stack = {'stack_identity': {'stack_id': 'foo', 'tenant': 'bar'}} result = stacks_view.format_stack(self.request, stack, None, tenant_safe=False) self.assertIn('project', result) self.assertEqual('bar', result['project']) def test_includes_all_other_keys(self): stack = {'foo': 'bar'} result = stacks_view.format_stack(self.request, stack) self.assertIn('foo', result) self.assertEqual('bar', result['foo']) def test_filter_out_all_but_given_keys(self): stack = { 'foo1': 'bar1', 'foo2': 'bar2', 'foo3': 'bar3', } result = stacks_view.format_stack(self.request, stack, ['foo2']) self.assertIn('foo2', result) self.assertNotIn('foo1', result) self.assertNotIn('foo3', result) class TestStacksViewBuilder(HeatTestCase): def setUp(self): super(TestStacksViewBuilder, self).setUp() self.request = mock.Mock() self.request.params = {} identity = identifier.HeatIdentifier('123456', 'wordpress', '1') self.stack1 = { u'stack_identity': dict(identity), u'updated_time': u'2012-07-09T09:13:11Z', u'template_description': u'blah', u'description': u'blah', u'stack_status_reason': u'Stack successfully created', u'creation_time': u'2012-07-09T09:12:45Z', u'stack_name': identity.stack_name, u'stack_action': u'CREATE', u'stack_status': u'COMPLETE', u'parameters': {'foo': 'bar'}, u'outputs': ['key', 'value'], u'notification_topics': [], u'capabilities': [], u'disable_rollback': True, u'timeout_mins': 60, } def test_stack_index(self): stacks = [self.stack1] stack_view = stacks_view.collection(self.request, stacks) self.assertIn('stacks', stack_view) self.assertEqual(1, len(stack_view['stacks'])) @mock.patch.object(stacks_view, 'format_stack') def test_stack_basic_details(self, mock_format_stack): stacks = [self.stack1] expected_keys = stacks_view.basic_keys stacks_view.collection(self.request, stacks) mock_format_stack.assert_called_once_with(self.request, self.stack1, expected_keys, mock.ANY) @mock.patch.object(stacks_view.views_common, 'get_collection_links') def test_append_collection_links(self, mock_get_collection_links): # If the page is full, assume a next page exists stacks = [self.stack1] mock_get_collection_links.return_value = 'fake links' stack_view = stacks_view.collection(self.request, stacks) self.assertIn('links', stack_view) @mock.patch.object(stacks_view.views_common, 'get_collection_links') def test_doesnt_append_collection_links(self, mock_get_collection_links): stacks = [self.stack1] mock_get_collection_links.return_value = None stack_view = stacks_view.collection(self.request, stacks) self.assertNotIn('links', stack_view) @mock.patch.object(stacks_view.views_common, 'get_collection_links') def test_append_collection_count(self, mock_get_collection_links): stacks = [self.stack1] count = 1 stack_view = stacks_view.collection(self.request, stacks, count) self.assertIn('count', stack_view) self.assertEqual(1, stack_view['count']) @mock.patch.object(stacks_view.views_common, 'get_collection_links') def test_doesnt_append_collection_count(self, mock_get_collection_links): stacks = [self.stack1] stack_view = stacks_view.collection(self.request, stacks) self.assertNotIn('count', stack_view) @mock.patch.object(stacks_view.views_common, 'get_collection_links') def test_appends_collection_count_of_zero(self, mock_get_collection_links): stacks = [self.stack1] count = 0 stack_view = stacks_view.collection(self.request, stacks, count) self.assertIn('count', stack_view) self.assertEqual(0, stack_view['count']) heat-2014.1.5/heat/tests/test_heat_autoscaling_group.py0000664000567000056700000003523312540642614024261 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. import copy import datetime from oslo.config import cfg from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine import resource from heat.engine import scheduler from heat.openstack.common import timeutils from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import generic_resource from heat.tests import utils class AutoScalingGroupTest(HeatTestCase): as_template = ''' heat_template_version: 2013-05-23 description: AutoScaling Test resources: my-group: properties: max_size: 5 min_size: 1 resource: type: ResourceWithProps properties: Foo: hello type: OS::Heat::AutoScalingGroup ''' def setUp(self): super(AutoScalingGroupTest, self).setUp() utils.setup_dummy_db() resource._register_class('ResourceWithProps', generic_resource.ResourceWithProps) cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() client = self.patchobject(clients.OpenStackClients, "keystone") client.return_value = self.fc self.parsed = template_format.parse(self.as_template) def create_stack(self, t): stack = utils.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) return stack def test_scaling_delete_empty(self): properties = self.parsed['resources']['my-group']['properties'] properties['min_size'] = 0 properties['max_size'] = 0 rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(0, len(rsrc.get_instances())) rsrc.delete() def test_scaling_adjust_down_empty(self): properties = self.parsed['resources']['my-group']['properties'] properties['min_size'] = 1 properties['max_size'] = 1 rsrc = self.create_stack(self.parsed)['my-group'] resources = rsrc.get_instances() self.assertEqual(1, len(resources)) # Reduce the min size to 0, should complete without adjusting update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['min_size'] = 0 scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(resources, rsrc.get_instances()) # trigger adjustment to reduce to 0, there should be no more instances rsrc.adjust(-1) self.assertEqual(0, len(rsrc.get_instances())) def test_scaling_group_update_replace(self): rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(1, len(rsrc.get_instances())) update_snippet = copy.deepcopy(rsrc.parsed_template()) props = update_snippet['Properties']['resource']['properties'] props['Foo'] = 'Bar' updater = scheduler.TaskRunner(rsrc.update, update_snippet) self.assertRaises(resource.UpdateReplace, updater) def test_scaling_group_suspend(self): rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(1, len(rsrc.get_instances())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) scheduler.TaskRunner(rsrc.suspend)() self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) def test_scaling_group_resume(self): rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(1, len(rsrc.get_instances())) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rsrc.state_set(rsrc.SUSPEND, rsrc.COMPLETE) for i in rsrc.nested().values(): i.state_set(rsrc.SUSPEND, rsrc.COMPLETE) scheduler.TaskRunner(rsrc.resume)() self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) def test_scaling_group_create_error(self): mock_create = self.patchobject(generic_resource.ResourceWithProps, 'handle_create') mock_create.side_effect = Exception("Creation failed!") rsrc = utils.parse_stack(self.parsed)['my-group'] self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.assertEqual(0, len(rsrc.get_instances())) def test_scaling_group_update_ok_maxsize(self): properties = self.parsed['resources']['my-group']['properties'] properties['min_size'] = 1 properties['max_size'] = 3 rsrc = self.create_stack(self.parsed)['my-group'] resources = rsrc.get_instances() self.assertEqual(1, len(resources)) # Reduce the max size to 2, should complete without adjusting update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['max_size'] = 2 scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(resources, rsrc.get_instances()) self.assertEqual(2, rsrc.properties['max_size']) def test_scaling_group_update_ok_minsize(self): properties = self.parsed['resources']['my-group']['properties'] properties['min_size'] = 1 properties['max_size'] = 3 rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(1, len(rsrc.get_instances())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['min_size'] = 2 scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(2, len(rsrc.get_instances())) self.assertEqual(2, rsrc.properties['min_size']) def test_scaling_group_update_ok_desired(self): properties = self.parsed['resources']['my-group']['properties'] properties['min_size'] = 1 properties['max_size'] = 3 rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(1, len(rsrc.get_instances())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['desired_capacity'] = 2 scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(2, len(rsrc.get_instances())) self.assertEqual(2, rsrc.properties['desired_capacity']) def test_scaling_group_update_ok_desired_remove(self): properties = self.parsed['resources']['my-group']['properties'] properties['desired_capacity'] = 2 rsrc = self.create_stack(self.parsed)['my-group'] resources = rsrc.get_instances() self.assertEqual(2, len(resources)) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties'].pop('desired_capacity') scheduler.TaskRunner(rsrc.update, update_snippet)() self.assertEqual(resources, rsrc.get_instances()) self.assertIsNone(rsrc.properties['desired_capacity']) def test_scaling_group_scale_up_failure(self): stack = self.create_stack(self.parsed) mock_create = self.patchobject(generic_resource.ResourceWithProps, 'handle_create') rsrc = stack['my-group'] self.assertEqual(1, len(rsrc.get_instances())) mock_create.side_effect = exception.Error('Bang') self.assertRaises(exception.Error, rsrc.adjust, 1) self.assertEqual(1, len(rsrc.get_instances())) def test_scaling_group_truncate_adjustment(self): # Create initial group, 2 instances properties = self.parsed['resources']['my-group']['properties'] properties['desired_capacity'] = 2 rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(2, len(rsrc.get_instances())) rsrc.adjust(4) self.assertEqual(5, len(rsrc.get_instances())) rsrc.adjust(-5) self.assertEqual(1, len(rsrc.get_instances())) rsrc.adjust(0) self.assertEqual(1, len(rsrc.get_instances())) def _do_test_scaling_group_percent(self, decrease, lowest, increase, create, highest): # Create initial group, 2 instances properties = self.parsed['resources']['my-group']['properties'] properties['desired_capacity'] = 2 rsrc = self.create_stack(self.parsed)['my-group'] self.assertEqual(2, len(rsrc.get_instances())) # reduce by decrease % rsrc.adjust(decrease, 'percentage_change_in_capacity') self.assertEqual(lowest, len(rsrc.get_instances())) # raise by increase % rsrc.adjust(increase, 'percentage_change_in_capacity') self.assertEqual(highest, len(rsrc.get_instances())) def test_scaling_group_percent(self): self._do_test_scaling_group_percent(-50, 1, 200, 2, 3) def test_scaling_group_percent_round_up(self): self._do_test_scaling_group_percent(-33, 1, 33, 1, 2) def test_scaling_group_percent_round_down(self): self._do_test_scaling_group_percent(-66, 1, 225, 2, 3) def test_min_min_size(self): self.parsed['resources']['my-group']['properties']['min_size'] = -1 stack = utils.parse_stack(self.parsed) self.assertRaises(exception.StackValidationFailed, stack['my-group'].validate) def test_min_max_size(self): self.parsed['resources']['my-group']['properties']['max_size'] = -1 stack = utils.parse_stack(self.parsed) self.assertRaises(exception.StackValidationFailed, stack['my-group'].validate) class HeatScalingGroupWithCFNScalingPolicyTest(HeatTestCase): as_template = ''' heat_template_version: 2013-05-23 description: AutoScaling Test resources: my-group: properties: max_size: 5 min_size: 1 resource: type: ResourceWithProps properties: Foo: hello type: OS::Heat::AutoScalingGroup scale-up: type: AWS::AutoScaling::ScalingPolicy properties: AutoScalingGroupName: {get_resource: my-group} ScalingAdjustment: 1 AdjustmentType: ChangeInCapacity Cooldown: 60 ''' def setUp(self): super(HeatScalingGroupWithCFNScalingPolicyTest, self).setUp() utils.setup_dummy_db() resource._register_class('ResourceWithProps', generic_resource.ResourceWithProps) cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.fc = fakes.FakeKeystoneClient() client = self.patchobject(clients.OpenStackClients, "keystone") client.return_value = self.fc self.parsed = template_format.parse(self.as_template) def create_stack(self, t): stack = utils.parse_stack(t) stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) return stack def test_scale_up(self): stack = self.create_stack(self.parsed) scale_up = stack['scale-up'] group = stack['my-group'] self.assertEqual(1, len(group.get_instances())) scale_up.signal() self.assertEqual(2, len(group.get_instances())) def test_no_instance_list(self): """ The InstanceList attribute is not inherited from AutoScalingResourceGroup's superclasses. """ stack = self.create_stack(self.parsed) group = stack['my-group'] self.assertRaises(exception.InvalidTemplateAttribute, group.FnGetAtt, 'InstanceList') class ScalingPolicyTest(HeatTestCase): as_template = ''' heat_template_version: 2013-05-23 resources: my-policy: type: OS::Heat::ScalingPolicy properties: auto_scaling_group_id: {get_resource: my-group} adjustment_type: change_in_capacity scaling_adjustment: 1 my-group: type: OS::Heat::AutoScalingGroup properties: max_size: 5 min_size: 1 resource: type: ResourceWithProps properties: Foo: hello ''' def setUp(self): super(ScalingPolicyTest, self).setUp() utils.setup_dummy_db() resource._register_class('ResourceWithProps', generic_resource.ResourceWithProps) self.fc = fakes.FakeKeystoneClient() client = self.patchobject(clients.OpenStackClients, "keystone") client.return_value = self.fc self.parsed = template_format.parse(self.as_template) def test_alarm_attribute(self): stack = utils.parse_stack(self.parsed) stack.create() policy = stack['my-policy'] self.assertIn("my-policy", policy.FnGetAtt('alarm_url')) def test_signal(self): stack = utils.parse_stack(self.parsed) stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) policy = stack['my-policy'] group = stack['my-group'] self.assertEqual("1234", policy.FnGetRefId()) self.assertEqual(1, len(group.get_instance_names())) policy.signal() self.assertEqual(2, len(group.get_instance_names())) def test_signal_with_cooldown(self): self.parsed['resources']['my-policy']['properties']['cooldown'] = 60 stack = utils.parse_stack(self.parsed) stack.create() policy = stack['my-policy'] group = stack['my-group'] self.assertEqual(1, len(group.get_instance_names())) policy.signal() self.assertEqual(2, len(group.get_instance_names())) policy.signal() # The second signal shouldn't have changed it because of cooldown self.assertEqual(2, len(group.get_instance_names())) past = timeutils.strtime(timeutils.utcnow() - datetime.timedelta(seconds=65)) policy.metadata = {past: 'ChangeInCapacity : 1'} policy.signal() self.assertEqual(3, len(group.get_instance_names())) heat-2014.1.5/heat/tests/utils.py0000664000567000056700000001261312540642614017631 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. import functools import random import string import sys import uuid from oslo.config import cfg import sqlalchemy from heat.common import context from heat.common import exception from heat.db import api as db_api from heat.engine import environment from heat.engine import parser from heat.engine import resource from heat.openstack.common.db.sqlalchemy import session get_engine = session.get_engine class UUIDStub(object): def __init__(self, value): self.value = value def __enter__(self): self.uuid4 = uuid.uuid4 uuid_stub = lambda: self.value uuid.uuid4 = uuid_stub def __exit__(self, *exc_info): uuid.uuid4 = self.uuid4 def random_name(): return ''.join(random.choice(string.ascii_uppercase) for x in range(10)) def stack_delete_after(test_fn): """ Decorator which calls test class self.stack.delete() to ensure tests clean up their stacks regardless of test success/failure """ @functools.wraps(test_fn) def wrapped_test(test_case, *args, **kwargs): def delete_stack(): stack = getattr(test_case, 'stack', None) if stack is not None and stack.id is not None: stack.delete() try: test_fn(test_case, *args, **kwargs) except: exc_class, exc_val, exc_tb = sys.exc_info() try: delete_stack() finally: raise exc_class, exc_val, exc_tb else: delete_stack() return wrapped_test def wr_delete_after(test_fn): """ Decorator which calls test class self.wr.destroy() to ensure tests clean up their watchrule regardless of test success/failure Used by tests which create watchrule objects directly to cleanup correctly self.wr can be either a single watchrule, or a list of several watchrules """ @functools.wraps(test_fn) def wrapped_test(test_case, *args, **kwargs): def delete_wrs(): wr = getattr(test_case, 'wr', None) try: for w in wr: delete_wr(w) except TypeError: delete_wr(wr) def delete_wr(w): if w.id is not None: try: w.destroy() except exception.NotFound: pass try: test_fn(test_case, *args, **kwargs) except: exc_class, exc_val, exc_tb = sys.exc_info() try: delete_wrs() finally: raise exc_class, exc_val, exc_tb else: delete_wrs() return wrapped_test def setup_dummy_db(): cfg.CONF.set_default('sqlite_synchronous', False) session.set_defaults(sql_connection="sqlite://", sqlite_db='heat.db') db_api.db_sync() engine = get_engine() engine.connect() def reset_dummy_db(): engine = get_engine() meta = sqlalchemy.MetaData() meta.reflect(bind=engine) for table in reversed(meta.sorted_tables): if table.name == 'migrate_version': continue engine.execute(table.delete()) def dummy_context(user='test_username', tenant_id='test_tenant_id', password='password', roles=[], user_id=None): return context.RequestContext.from_dict({ 'tenant_id': tenant_id, 'tenant': 'test_tenant', 'username': user, 'user_id': user_id, 'password': password, 'roles': roles, 'is_admin': False, 'auth_url': 'http://server.test:5000/v2.0', 'auth_token': 'abcd1234' }) def parse_stack(t, params={}, stack_name='test_stack', stack_id=None, timeout_mins=None): ctx = dummy_context() template = parser.Template(t) stack = parser.Stack(ctx, stack_name, template, environment.Environment(params), stack_id, timeout_mins=timeout_mins) stack.store() return stack class PhysName(object): mock_short_id = 'x' * 12 def __init__(self, stack_name, resource_name, limit=255): name = '%s-%s-%s' % (stack_name, resource_name, self.mock_short_id) self._physname = resource.Resource.reduce_physical_resource_name( name, limit) self.stack, self.res, self.sid = self._physname.rsplit('-', 2) def __eq__(self, physical_name): try: stack, res, short_id = str(physical_name).rsplit('-', 2) except ValueError: return False if len(short_id) != len(self.mock_short_id): return False # ignore the stack portion of the name, as it may have been truncated return res == self.res def __ne__(self, physical_name): return not self.__eq__(physical_name) def __repr__(self): return self._physname heat-2014.1.5/heat/tests/test_software_config.py0000664000567000056700000001027112540642614022705 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. import mock from heat.common import exception from heat.engine import parser from heat.engine import template import heat.engine.resources.software_config.software_config as sc from heatclient.exc import HTTPNotFound from heat.tests.common import HeatTestCase from heat.tests import utils class SoftwareConfigTest(HeatTestCase): def setUp(self): super(SoftwareConfigTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() self.properties = { 'group': 'Heat::Shell', 'inputs': [], 'outputs': [], 'options': {}, 'config': '#!/bin/bash' } self.stack = parser.Stack( self.ctx, 'software_config_test_stack', template.Template({ 'Resources': { 'config_mysql': { 'Type': 'OS::Heat::SoftwareConfig', 'Properties': self.properties }}})) self.config = self.stack['config_mysql'] heat = mock.MagicMock() self.heatclient = mock.MagicMock() self.config.heat = heat heat.return_value = self.heatclient self.software_configs = self.heatclient.software_configs def test_resource_mapping(self): mapping = sc.resource_mapping() self.assertEqual(1, len(mapping)) self.assertEqual(sc.SoftwareConfig, mapping['OS::Heat::SoftwareConfig']) self.assertIsInstance(self.config, sc.SoftwareConfig) def test_handle_create(self): value = mock.MagicMock() config_id = 'c8a19429-7fde-47ea-a42f-40045488226c' value.id = config_id self.software_configs.create.return_value = value self.config.handle_create() self.assertEqual(config_id, self.config.resource_id) def test_handle_delete(self): self.resource_id = None self.assertIsNone(self.config.handle_delete()) config_id = 'c8a19429-7fde-47ea-a42f-40045488226c' self.config.resource_id = config_id self.software_configs.delete.return_value = None self.assertIsNone(self.config.handle_delete()) self.software_configs.delete.side_effect = HTTPNotFound() self.assertIsNone(self.config.handle_delete()) def test_get_software_config(self): config_id = 'c8a19429-7fde-47ea-a42f-40045488226c' value = mock.MagicMock() value.config = '#!/bin/bash' self.software_configs.get.return_value = value heatclient = self.heatclient config = sc.SoftwareConfig.get_software_config(heatclient, config_id) self.assertEqual('#!/bin/bash', config) self.software_configs.get.side_effect = HTTPNotFound() err = self.assertRaises( exception.SoftwareConfigMissing, self.config.get_software_config, heatclient, config_id) self.assertEqual( ('The config (c8a19429-7fde-47ea-a42f-40045488226c) ' 'could not be found.'), str(err)) def test_resolve_attribute(self): self.assertIsNone(self.config._resolve_attribute('others')) self.config.resource_id = None self.assertIsNone(self.config._resolve_attribute('config')) self.config.resource_id = 'c8a19429-7fde-47ea-a42f-40045488226c' value = mock.MagicMock() value.config = '#!/bin/bash' self.software_configs.get.return_value = value self.assertEqual( '#!/bin/bash', self.config._resolve_attribute('config')) self.software_configs.get.side_effect = HTTPNotFound() self.assertEqual('', self.config._resolve_attribute('config')) heat-2014.1.5/heat/tests/test_properties.py0000664000567000056700000017633712540642614021742 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. import testtools from heat.common import exception from heat.engine import constraints from heat.engine.hot import parameters as hot_param from heat.engine import parameters from heat.engine import properties from heat.engine import resources from heat.engine import support class PropertySchemaTest(testtools.TestCase): def test_schema_all(self): d = { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'update_allowed': False, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } s = properties.Schema(properties.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) self.assertEqual(d, dict(s)) def test_schema_list_schema(self): d = { 'type': 'list', 'description': 'A list', 'schema': { '*': { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'update_allowed': False, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } }, 'required': False, 'update_allowed': False } s = properties.Schema(properties.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) l = properties.Schema(properties.Schema.LIST, 'A list', schema=s) self.assertEqual(d, dict(l)) def test_schema_map_schema(self): d = { 'type': 'map', 'description': 'A map', 'schema': { 'Foo': { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'update_allowed': False, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } }, 'required': False, 'update_allowed': False, } s = properties.Schema(properties.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) m = properties.Schema(properties.Schema.MAP, 'A map', schema={'Foo': s}) self.assertEqual(d, dict(m)) def test_schema_nested_schema(self): d = { 'type': 'list', 'description': 'A list', 'schema': { '*': { 'type': 'map', 'description': 'A map', 'schema': { 'Foo': { 'type': 'string', 'description': 'A string', 'default': 'wibble', 'required': True, 'update_allowed': False, 'constraints': [ {'length': {'min': 4, 'max': 8}}, ] } }, 'required': False, 'update_allowed': False, } }, 'required': False, 'update_allowed': False, } s = properties.Schema(properties.Schema.STRING, 'A string', default='wibble', required=True, constraints=[constraints.Length(4, 8)]) m = properties.Schema(properties.Schema.MAP, 'A map', schema={'Foo': s}) l = properties.Schema(properties.Schema.LIST, 'A list', schema=m) self.assertEqual(d, dict(l)) def test_all_resource_schemata(self): for resource_type in resources.global_env().get_types(): for schema in getattr(resource_type, 'properties_schema', {}).itervalues(): properties.Schema.from_legacy(schema) def test_from_legacy_idempotency(self): s = properties.Schema(properties.Schema.STRING) self.assertTrue(properties.Schema.from_legacy(s) is s) def test_from_legacy_minimal_string(self): s = properties.Schema.from_legacy({ 'Type': 'String', }) self.assertEqual(properties.Schema.STRING, s.type) self.assertIsNone(s.description) self.assertIsNone(s.default) self.assertFalse(s.required) self.assertEqual(0, len(s.constraints)) def test_from_legacy_string(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'Description': 'a string', 'Default': 'wibble', 'Required': True, 'Implemented': False, 'MinLength': 4, 'MaxLength': 8, 'AllowedValues': ['blarg', 'wibble'], 'AllowedPattern': '[a-z]*', }) self.assertEqual(properties.Schema.STRING, s.type) self.assertEqual('a string', s.description) self.assertEqual('wibble', s.default) self.assertTrue(s.required) self.assertEqual(3, len(s.constraints)) def test_from_legacy_min_length(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'MinLength': 4, }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Length) self.assertEqual(4, c.min) self.assertIsNone(c.max) def test_from_legacy_max_length(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'MaxLength': 8, }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Length) self.assertIsNone(c.min) self.assertEqual(8, c.max) def test_from_legacy_minmax_length(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'MinLength': 4, 'MaxLength': 8, }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Length) self.assertEqual(4, c.min) self.assertEqual(8, c.max) def test_from_legacy_minmax_string_length(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'MinLength': '4', 'MaxLength': '8', }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Length) self.assertEqual(4, c.min) self.assertEqual(8, c.max) def test_from_legacy_min_value(self): s = properties.Schema.from_legacy({ 'Type': 'Integer', 'MinValue': 4, }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Range) self.assertEqual(4, c.min) self.assertIsNone(c.max) def test_from_legacy_max_value(self): s = properties.Schema.from_legacy({ 'Type': 'Integer', 'MaxValue': 8, }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Range) self.assertIsNone(c.min) self.assertEqual(8, c.max) def test_from_legacy_minmax_value(self): s = properties.Schema.from_legacy({ 'Type': 'Integer', 'MinValue': 4, 'MaxValue': 8, }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Range) self.assertEqual(4, c.min) self.assertEqual(8, c.max) def test_from_legacy_minmax_string_value(self): s = properties.Schema.from_legacy({ 'Type': 'Integer', 'MinValue': '4', 'MaxValue': '8', }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.Range) self.assertEqual(4, c.min) self.assertEqual(8, c.max) def test_from_legacy_allowed_values(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'AllowedValues': ['blarg', 'wibble'], }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.AllowedValues) self.assertEqual(('blarg', 'wibble'), c.allowed) def test_from_legacy_allowed_pattern(self): s = properties.Schema.from_legacy({ 'Type': 'String', 'AllowedPattern': '[a-z]*', }) self.assertEqual(1, len(s.constraints)) c = s.constraints[0] self.assertIsInstance(c, constraints.AllowedPattern) self.assertEqual('[a-z]*', c.pattern) def test_from_legacy_list(self): l = properties.Schema.from_legacy({ 'Type': 'List', 'Default': ['wibble'], 'Schema': { 'Type': 'String', 'Default': 'wibble', 'MaxLength': 8, } }) self.assertEqual(properties.Schema.LIST, l.type) self.assertEqual(['wibble'], l.default) ss = l.schema[0] self.assertEqual(properties.Schema.STRING, ss.type) self.assertEqual('wibble', ss.default) def test_from_legacy_map(self): l = properties.Schema.from_legacy({ 'Type': 'Map', 'Schema': { 'foo': { 'Type': 'String', 'Default': 'wibble', } } }) self.assertEqual(properties.Schema.MAP, l.type) ss = l.schema['foo'] self.assertEqual(properties.Schema.STRING, ss.type) self.assertEqual('wibble', ss.default) def test_from_legacy_invalid_key(self): self.assertRaises(constraints.InvalidSchemaError, properties.Schema.from_legacy, {'Type': 'String', 'Foo': 'Bar'}) def test_from_string_param(self): description = "WebServer EC2 instance type" allowed_values = ["t1.micro", "m1.small", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge"] constraint_desc = "Must be a valid EC2 instance type." param = parameters.Schema.from_dict({ "Type": "String", "Description": description, "Default": "m1.large", "AllowedValues": allowed_values, "ConstraintDescription": constraint_desc, }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.STRING, schema.type) self.assertEqual(description, schema.description) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) allowed_constraint = schema.constraints[0] self.assertEqual(tuple(allowed_values), allowed_constraint.allowed) self.assertEqual(constraint_desc, allowed_constraint.description) def test_from_string_allowed_pattern(self): description = "WebServer EC2 instance type" allowed_pattern = "[A-Za-z0-9.]*" constraint_desc = "Must contain only alphanumeric characters." param = parameters.Schema.from_dict({ "Type": "String", "Description": description, "Default": "m1.large", "AllowedPattern": allowed_pattern, "ConstraintDescription": constraint_desc, }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.STRING, schema.type) self.assertEqual(description, schema.description) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) allowed_constraint = schema.constraints[0] self.assertEqual(allowed_pattern, allowed_constraint.pattern) self.assertEqual(constraint_desc, allowed_constraint.description) def test_from_string_multi_constraints(self): description = "WebServer EC2 instance type" allowed_pattern = "[A-Za-z0-9.]*" constraint_desc = "Must contain only alphanumeric characters." param = parameters.Schema.from_dict({ "Type": "String", "Description": description, "Default": "m1.large", "MinLength": "7", "AllowedPattern": allowed_pattern, "ConstraintDescription": constraint_desc, }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.STRING, schema.type) self.assertEqual(description, schema.description) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(2, len(schema.constraints)) len_constraint = schema.constraints[0] allowed_constraint = schema.constraints[1] self.assertEqual(7, len_constraint.min) self.assertIsNone(len_constraint.max) self.assertEqual(allowed_pattern, allowed_constraint.pattern) self.assertEqual(constraint_desc, allowed_constraint.description) def test_from_param_string_min_len(self): param = parameters.Schema.from_dict({ "Description": "WebServer EC2 instance type", "Type": "String", "Default": "m1.large", "MinLength": "7", }) schema = properties.Schema.from_parameter(param) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) len_constraint = schema.constraints[0] self.assertEqual(7, len_constraint.min) self.assertIsNone(len_constraint.max) def test_from_param_string_max_len(self): param = parameters.Schema.from_dict({ "Description": "WebServer EC2 instance type", "Type": "String", "Default": "m1.large", "MaxLength": "11", }) schema = properties.Schema.from_parameter(param) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) len_constraint = schema.constraints[0] self.assertIsNone(len_constraint.min) self.assertEqual(11, len_constraint.max) def test_from_param_string_min_max_len(self): param = parameters.Schema.from_dict({ "Description": "WebServer EC2 instance type", "Type": "String", "Default": "m1.large", "MinLength": "7", "MaxLength": "11", }) schema = properties.Schema.from_parameter(param) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) len_constraint = schema.constraints[0] self.assertEqual(7, len_constraint.min) self.assertEqual(11, len_constraint.max) def test_from_param_no_default(self): param = parameters.Schema.from_dict({ "Description": "WebServer EC2 instance type", "Type": "String", }) schema = properties.Schema.from_parameter(param) self.assertTrue(schema.required) self.assertIsNone(schema.default) self.assertEqual(0, len(schema.constraints)) def test_from_number_param_min(self): default = "42" param = parameters.Schema.from_dict({ "Type": "Number", "Default": default, "MinValue": "10", }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.NUMBER, schema.type) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) value_constraint = schema.constraints[0] self.assertEqual(10, value_constraint.min) self.assertIsNone(value_constraint.max) def test_from_number_param_max(self): default = "42" param = parameters.Schema.from_dict({ "Type": "Number", "Default": default, "MaxValue": "100", }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.NUMBER, schema.type) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) value_constraint = schema.constraints[0] self.assertIsNone(value_constraint.min) self.assertEqual(100, value_constraint.max) def test_from_number_param_min_max(self): default = "42" param = parameters.Schema.from_dict({ "Type": "Number", "Default": default, "MinValue": "10", "MaxValue": "100", }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.NUMBER, schema.type) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) value_constraint = schema.constraints[0] self.assertEqual(10, value_constraint.min) self.assertEqual(100, value_constraint.max) def test_from_number_param_allowed_vals(self): default = "42" constraint_desc = "The quick brown fox jumps over the lazy dog." param = parameters.Schema.from_dict({ "Type": "Number", "Default": default, "AllowedValues": ["10", "42", "100"], "ConstraintDescription": constraint_desc, }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.NUMBER, schema.type) self.assertIsNone(schema.default) self.assertFalse(schema.required) self.assertEqual(1, len(schema.constraints)) allowed_constraint = schema.constraints[0] self.assertEqual(('10', '42', '100'), allowed_constraint.allowed) self.assertEqual(constraint_desc, allowed_constraint.description) def test_from_list_param(self): param = parameters.Schema.from_dict({ "Type": "CommaDelimitedList", "Default": "foo,bar,baz" }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.LIST, schema.type) self.assertIsNone(schema.default) self.assertFalse(schema.required) def test_from_json_param(self): param = parameters.Schema.from_dict({ "Type": "Json", "Default": {"foo": "bar", "blarg": "wibble"} }) schema = properties.Schema.from_parameter(param) self.assertEqual(properties.Schema.MAP, schema.type) self.assertIsNone(schema.default) self.assertFalse(schema.required) class PropertyTest(testtools.TestCase): def test_required_default(self): p = properties.Property({'Type': 'String'}) self.assertFalse(p.required()) def test_required_false(self): p = properties.Property({'Type': 'String', 'Required': False}) self.assertFalse(p.required()) def test_required_true(self): p = properties.Property({'Type': 'String', 'Required': True}) self.assertTrue(p.required()) def test_implemented_default(self): p = properties.Property({'Type': 'String'}) self.assertTrue(p.implemented()) def test_implemented_false(self): p = properties.Property({'Type': 'String', 'Implemented': False}) self.assertFalse(p.implemented()) def test_implemented_true(self): p = properties.Property({'Type': 'String', 'Implemented': True}) self.assertTrue(p.implemented()) def test_no_default(self): p = properties.Property({'Type': 'String'}) self.assertFalse(p.has_default()) def test_default(self): p = properties.Property({'Type': 'String', 'Default': 'wibble'}) self.assertEqual('wibble', p.default()) def test_type(self): p = properties.Property({'Type': 'String'}) self.assertEqual('String', p.type()) def test_bad_type(self): self.assertRaises(constraints.InvalidSchemaError, properties.Property, {'Type': 'Fish'}) def test_bad_key(self): self.assertRaises(constraints.InvalidSchemaError, properties.Property, {'Type': 'String', 'Foo': 'Bar'}) def test_string_pattern_good(self): schema = {'Type': 'String', 'AllowedPattern': '[a-z]*'} p = properties.Property(schema) self.assertEqual('foo', p.validate_data('foo')) def test_string_pattern_bad_prefix(self): schema = {'Type': 'String', 'AllowedPattern': '[a-z]*'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, '1foo') def test_string_pattern_bad_suffix(self): schema = {'Type': 'String', 'AllowedPattern': '[a-z]*'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 'foo1') def test_string_value_list_good(self): schema = {'Type': 'String', 'AllowedValues': ['foo', 'bar', 'baz']} p = properties.Property(schema) self.assertEqual('bar', p.validate_data('bar')) def test_string_value_list_bad(self): schema = {'Type': 'String', 'AllowedValues': ['foo', 'bar', 'baz']} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 'blarg') def test_string_maxlength_good(self): schema = {'Type': 'String', 'MaxLength': '5'} p = properties.Property(schema) self.assertEqual('abcd', p.validate_data('abcd')) def test_string_exceeded_maxlength(self): schema = {'Type': 'String', 'MaxLength': '5'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 'abcdef') def test_string_length_in_range(self): schema = {'Type': 'String', 'MinLength': '5', 'MaxLength': '10'} p = properties.Property(schema) self.assertEqual('abcdef', p.validate_data('abcdef')) def test_string_minlength_good(self): schema = {'Type': 'String', 'MinLength': '5'} p = properties.Property(schema) self.assertEqual('abcde', p.validate_data('abcde')) def test_string_smaller_than_minlength(self): schema = {'Type': 'String', 'MinLength': '5'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 'abcd') def test_int_good(self): schema = {'Type': 'Integer', 'MinValue': 3, 'MaxValue': 3} p = properties.Property(schema) self.assertEqual(3, p.validate_data(3)) def test_int_bad(self): schema = {'Type': 'Integer'} p = properties.Property(schema) ex = self.assertRaises(TypeError, p.validate_data, [1]) self.assertEqual("int() argument must be a string or a number, " "not 'list'", str(ex)) def test_int_from_str_good(self): schema = {'Type': 'Integer'} p = properties.Property(schema) self.assertEqual(3, p.validate_data('3')) def test_int_from_str_bad(self): schema = {'Type': 'Integer'} p = properties.Property(schema) ex = self.assertRaises(TypeError, p.validate_data, '3a') self.assertEqual("Value '3a' is not an integer", str(ex)) def test_integer_low(self): schema = {'Type': 'Integer', 'MinValue': 4} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 3) def test_integer_high(self): schema = {'Type': 'Integer', 'MaxValue': 2} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 3) def test_integer_value_list_good(self): schema = {'Type': 'Integer', 'AllowedValues': [1, 3, 5]} p = properties.Property(schema) self.assertEqual(5, p.validate_data(5)) def test_integer_value_list_bad(self): schema = {'Type': 'Integer', 'AllowedValues': [1, 3, 5]} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, 2) def test_number_good(self): schema = {'Type': 'Number', 'MinValue': '3', 'MaxValue': '3'} p = properties.Property(schema) self.assertEqual(3, p.validate_data(3)) def test_numbers_from_strings(self): """Numbers can be converted from strings.""" schema = {'Type': 'Number', 'MinValue': '3', 'MaxValue': '3'} p = properties.Property(schema) self.assertEqual(3, p.validate_data('3')) def test_number_value_list_good(self): schema = {'Type': 'Number', 'AllowedValues': [1, 3, 5]} p = properties.Property(schema) self.assertEqual(5, p.validate_data('5')) def test_number_value_list_bad(self): schema = {'Type': 'Number', 'AllowedValues': ['1', '3', '5']} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, '2') def test_number_low(self): schema = {'Type': 'Number', 'MinValue': '4'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, '3') def test_number_high(self): schema = {'Type': 'Number', 'MaxValue': '2'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, '3') def test_boolean_true(self): p = properties.Property({'Type': 'Boolean'}) self.assertIs(True, p.validate_data('True')) self.assertIs(True, p.validate_data('true')) self.assertIs(True, p.validate_data(True)) def test_boolean_false(self): p = properties.Property({'Type': 'Boolean'}) self.assertIs(False, p.validate_data('False')) self.assertIs(False, p.validate_data('false')) self.assertIs(False, p.validate_data(False)) def test_boolean_invalid(self): p = properties.Property({'Type': 'Boolean'}) self.assertRaises(ValueError, p.validate_data, 'fish') def test_list_string(self): p = properties.Property({'Type': 'List'}) self.assertRaises(TypeError, p.validate_data, 'foo') def test_list_good(self): p = properties.Property({'Type': 'List'}) self.assertEqual(['foo', 'bar'], p.validate_data(['foo', 'bar'])) def test_list_dict(self): p = properties.Property({'Type': 'List'}) self.assertRaises(TypeError, p.validate_data, {'foo': 'bar'}) def test_list_maxlength_good(self): schema = {'Type': 'List', 'MaxLength': '3'} p = properties.Property(schema) self.assertEqual(['1', '2'], p.validate_data(['1', '2'])) def test_list_exceeded_maxlength(self): schema = {'Type': 'List', 'MaxLength': '2'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, ['1', '2', '3']) def test_list_length_in_range(self): schema = {'Type': 'List', 'MinLength': '2', 'MaxLength': '4'} p = properties.Property(schema) self.assertEqual(['1', '2', '3'], p.validate_data(['1', '2', '3'])) def test_list_minlength_good(self): schema = {'Type': 'List', 'MinLength': '3'} p = properties.Property(schema) self.assertEqual(['1', '2', '3'], p.validate_data(['1', '2', '3'])) def test_list_smaller_than_minlength(self): schema = {'Type': 'List', 'MinLength': '4'} p = properties.Property(schema) self.assertRaises(ValueError, p.validate_data, ['1', '2', '3']) def test_map_string(self): p = properties.Property({'Type': 'Map'}) self.assertRaises(TypeError, p.validate_data, 'foo') def test_map_list(self): p = properties.Property({'Type': 'Map'}) self.assertRaises(TypeError, p.validate_data, ['foo']) def test_map_schema_good(self): map_schema = {'valid': {'Type': 'Boolean'}} p = properties.Property({'Type': 'Map', 'Schema': map_schema}) self.assertEqual({'valid': True}, p.validate_data({'valid': 'TRUE'})) def test_map_schema_bad_data(self): map_schema = {'valid': {'Type': 'Boolean'}} p = properties.Property({'Type': 'Map', 'Schema': map_schema}) ex = self.assertRaises(exception.StackValidationFailed, p.validate_data, {'valid': 'fish'}) self.assertEqual('Property error : valid "fish" is not ' 'a valid boolean', str(ex)) def test_map_schema_missing_data(self): map_schema = {'valid': {'Type': 'Boolean'}} p = properties.Property({'Type': 'Map', 'Schema': map_schema}) self.assertEqual({'valid': None}, p.validate_data({})) def test_map_schema_missing_required_data(self): map_schema = {'valid': {'Type': 'Boolean', 'Required': True}} p = properties.Property({'Type': 'Map', 'Schema': map_schema}) ex = self.assertRaises(exception.StackValidationFailed, p.validate_data, {}) self.assertEqual('Property error : Property valid not assigned', str(ex)) def test_list_schema_good(self): map_schema = {'valid': {'Type': 'Boolean'}} list_schema = {'Type': 'Map', 'Schema': map_schema} p = properties.Property({'Type': 'List', 'Schema': list_schema}) self.assertEqual([{'valid': True}, {'valid': False}], p.validate_data([{'valid': 'TRUE'}, {'valid': 'False'}])) def test_list_schema_bad_data(self): map_schema = {'valid': {'Type': 'Boolean'}} list_schema = {'Type': 'Map', 'Schema': map_schema} p = properties.Property({'Type': 'List', 'Schema': list_schema}) ex = self.assertRaises(exception.StackValidationFailed, p.validate_data, [{'valid': 'True'}, {'valid': 'fish'}]) self.assertEqual('Property error : 1 Property error : 1: valid ' '"fish" is not a valid boolean', str(ex)) def test_list_schema_int_good(self): list_schema = {'Type': 'Integer'} p = properties.Property({'Type': 'List', 'Schema': list_schema}) self.assertEqual([1, 2, 3], p.validate_data([1, 2, 3])) def test_list_schema_int_bad_data(self): list_schema = {'Type': 'Integer'} p = properties.Property({'Type': 'List', 'Schema': list_schema}) ex = self.assertRaises(exception.StackValidationFailed, p.validate_data, [42, 'fish']) self.assertEqual('Property error : 1 Value \'fish\' is not ' 'an integer', str(ex)) class PropertiesTest(testtools.TestCase): def setUp(self): super(PropertiesTest, self).setUp() schema = { 'int': {'Type': 'Integer'}, 'string': {'Type': 'String'}, 'required_int': {'Type': 'Integer', 'Required': True}, 'bad_int': {'Type': 'Integer'}, 'missing': {'Type': 'Integer'}, 'defaulted': {'Type': 'Integer', 'Default': 1}, 'default_override': {'Type': 'Integer', 'Default': 1}, } data = { 'int': 21, 'string': 'foo', 'bad_int': 'foo', 'default_override': 21, } double = lambda d: d * 2 self.props = properties.Properties(schema, data, double, 'wibble') def test_integer_good(self): self.assertEqual(42, self.props['int']) def test_string_good(self): self.assertEqual('foofoo', self.props['string']) def test_missing_required(self): self.assertRaises(ValueError, self.props.get, 'required_int') def test_integer_bad(self): self.assertRaises(ValueError, self.props.get, 'bad_int') def test_missing(self): self.assertIsNone(self.props['missing']) def test_default(self): self.assertEqual(1, self.props['defaulted']) def test_default_override(self): self.assertEqual(42, self.props['default_override']) def test_bad_key(self): self.assertEqual('wibble', self.props.get('foo', 'wibble')) def test_none_string(self): schema = {'foo': {'Type': 'String'}} props = properties.Properties(schema, {'foo': None}) self.assertEqual('', props['foo']) def test_none_integer(self): schema = {'foo': {'Type': 'Integer'}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(0, props['foo']) def test_none_number(self): schema = {'foo': {'Type': 'Number'}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(0, props['foo']) def test_none_boolean(self): schema = {'foo': {'Type': 'Boolean'}} props = properties.Properties(schema, {'foo': None}) self.assertIs(False, props['foo']) def test_none_map(self): schema = {'foo': {'Type': 'Map'}} props = properties.Properties(schema, {'foo': None}) self.assertEqual({}, props['foo']) def test_none_list(self): schema = {'foo': {'Type': 'List'}} props = properties.Properties(schema, {'foo': None}) self.assertEqual([], props['foo']) def test_none_default_string(self): schema = {'foo': {'Type': 'String', 'Default': 'bar'}} props = properties.Properties(schema, {'foo': None}) self.assertEqual('bar', props['foo']) def test_none_default_integer(self): schema = {'foo': {'Type': 'Integer', 'Default': 42}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(42, props['foo']) schema = {'foo': {'Type': 'Integer', 'Default': 0}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(0, props['foo']) schema = {'foo': {'Type': 'Integer', 'Default': -273}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(-273, props['foo']) def test_none_default_number(self): schema = {'foo': {'Type': 'Number', 'Default': 42.0}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(42.0, props['foo']) schema = {'foo': {'Type': 'Number', 'Default': 0.0}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(0.0, props['foo']) schema = {'foo': {'Type': 'Number', 'Default': -273.15}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(-273.15, props['foo']) def test_none_default_boolean(self): schema = {'foo': {'Type': 'Boolean', 'Default': True}} props = properties.Properties(schema, {'foo': None}) self.assertIs(True, props['foo']) def test_none_default_map(self): schema = {'foo': {'Type': 'Map', 'Default': {'bar': 'baz'}}} props = properties.Properties(schema, {'foo': None}) self.assertEqual({'bar': 'baz'}, props['foo']) def test_none_default_list(self): schema = {'foo': {'Type': 'List', 'Default': ['one', 'two']}} props = properties.Properties(schema, {'foo': None}) self.assertEqual(['one', 'two'], props['foo']) def test_bad_resolver(self): schema = {'foo': {'Type': 'String', 'Default': 'bar'}} def bad_resolver(prop): raise Exception('resolution failed!') props = properties.Properties(schema, {'foo': 'baz'}, bad_resolver) err = self.assertRaises(ValueError, props.get, 'foo') self.assertEqual('foo resolution failed!', str(err)) def test_schema_from_params(self): params_snippet = { "DBUsername": { "Type": "String", "Description": "The WordPress database admin account username", "Default": "admin", "MinLength": "1", "AllowedPattern": "[a-zA-Z][a-zA-Z0-9]*", "NoEcho": "true", "MaxLength": "16", "ConstraintDescription": ("must begin with a letter and " "contain only alphanumeric " "characters.") }, "KeyName": { "Type": "String", "Description": ("Name of an existing EC2 KeyPair to enable " "SSH access to the instances") }, "LinuxDistribution": { "Default": "F17", "Type": "String", "Description": "Distribution of choice", "AllowedValues": [ "F18", "F17", "U10", "RHEL-6.1", "RHEL-6.2", "RHEL-6.3" ] }, "DBPassword": { "Type": "String", "Description": "The WordPress database admin account password", "Default": "admin", "MinLength": "1", "AllowedPattern": "[a-zA-Z0-9]*", "NoEcho": "true", "MaxLength": "41", "ConstraintDescription": ("must contain only alphanumeric " "characters.") }, "DBName": { "AllowedPattern": "[a-zA-Z][a-zA-Z0-9]*", "Type": "String", "Description": "The WordPress database name", "MaxLength": "64", "Default": "wordpress", "MinLength": "1", "ConstraintDescription": ("must begin with a letter and " "contain only alphanumeric " "characters.") }, "InstanceType": { "Default": "m1.large", "Type": "String", "ConstraintDescription": "must be a valid EC2 instance type.", "Description": "WebServer EC2 instance type", "AllowedValues": [ "t1.micro", "m1.small", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge" ] }, "DBRootPassword": { "Type": "String", "Description": "Root password for MySQL", "Default": "admin", "MinLength": "1", "AllowedPattern": "[a-zA-Z0-9]*", "NoEcho": "true", "MaxLength": "41", "ConstraintDescription": ("must contain only alphanumeric " "characters.") } } expected = { "DBUsername": { "type": "string", "description": "The WordPress database admin account username", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 16}, "description": "must begin with a letter and contain " "only alphanumeric characters."}, {"allowed_pattern": "[a-zA-Z][a-zA-Z0-9]*", "description": "must begin with a letter and contain " "only alphanumeric characters."}, ] }, "LinuxDistribution": { "type": "string", "description": "Distribution of choice", "required": False, 'update_allowed': True, "constraints": [ {"allowed_values": ["F18", "F17", "U10", "RHEL-6.1", "RHEL-6.2", "RHEL-6.3"]} ] }, "InstanceType": { "type": "string", "description": "WebServer EC2 instance type", "required": False, 'update_allowed': True, "constraints": [ {"allowed_values": ["t1.micro", "m1.small", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge"], "description": "must be a valid EC2 instance type."}, ] }, "DBRootPassword": { "type": "string", "description": "Root password for MySQL", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 41}, "description": "must contain only alphanumeric " "characters."}, {"allowed_pattern": "[a-zA-Z0-9]*", "description": "must contain only alphanumeric " "characters."}, ] }, "KeyName": { "type": "string", "description": ("Name of an existing EC2 KeyPair to enable " "SSH access to the instances"), "required": True, 'update_allowed': True, }, "DBPassword": { "type": "string", "description": "The WordPress database admin account password", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 41}, "description": "must contain only alphanumeric " "characters."}, {"allowed_pattern": "[a-zA-Z0-9]*", "description": "must contain only alphanumeric " "characters."}, ] }, "DBName": { "type": "string", "description": "The WordPress database name", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 64}, "description": "must begin with a letter and contain " "only alphanumeric characters."}, {"allowed_pattern": "[a-zA-Z][a-zA-Z0-9]*", "description": "must begin with a letter and contain " "only alphanumeric characters."}, ] }, } params = dict((n, parameters.Schema.from_dict(s)) for n, s in params_snippet.items()) props_schemata = properties.Properties.schema_from_params(params) self.assertEqual(expected, dict((n, dict(s)) for n, s in props_schemata.items())) def test_schema_from_hot_params(self): params_snippet = { "KeyName": { "type": "string", "description": ("Name of an existing EC2 KeyPair to enable " "SSH access to the instances") }, "InstanceType": { "default": "m1.large", "type": "string", "description": "WebServer EC2 instance type", "constraints": [ {"allowed_values": ["t1.micro", "m1.small", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge"], "description": "Must be a valid EC2 instance type."} ] }, "LinuxDistribution": { "default": "F17", "type": "string", "description": "Distribution of choice", "constraints": [ {"allowed_values": ["F18", "F17", "U10", "RHEL-6.1", "RHEL-6.2", "RHEL-6.3"], "description": "Must be a valid Linux distribution"} ] }, "DBName": { "type": "string", "description": "The WordPress database name", "default": "wordpress", "constraints": [ {"length": {"min": 1, "max": 64}, "description": "Length must be between 1 and 64"}, {"allowed_pattern": "[a-zA-Z][a-zA-Z0-9]*", "description": ("Must begin with a letter and contain " "only alphanumeric characters.")} ] }, "DBUsername": { "type": "string", "description": "The WordPress database admin account username", "default": "admin", "hidden": "true", "constraints": [ {"length": {"min": 1, "max": 16}, "description": "Length must be between 1 and 16"}, {"allowed_pattern": "[a-zA-Z][a-zA-Z0-9]*", "description": ("Must begin with a letter and only " "contain alphanumeric characters")} ] }, "DBPassword": { "type": "string", "description": "The WordPress database admin account password", "default": "admin", "hidden": "true", "constraints": [ {"length": {"min": 1, "max": 41}, "description": "Length must be between 1 and 41"}, {"allowed_pattern": "[a-zA-Z0-9]*", "description": ("Must contain only alphanumeric " "characters")} ] }, "DBRootPassword": { "type": "string", "description": "Root password for MySQL", "default": "admin", "hidden": "true", "constraints": [ {"length": {"min": 1, "max": 41}, "description": "Length must be between 1 and 41"}, {"allowed_pattern": "[a-zA-Z0-9]*", "description": ("Must contain only alphanumeric " "characters")} ] } } expected = { "KeyName": { "type": "string", "description": ("Name of an existing EC2 KeyPair to enable " "SSH access to the instances"), "required": True, 'update_allowed': True, }, "InstanceType": { "type": "string", "description": "WebServer EC2 instance type", "required": False, 'update_allowed': True, "constraints": [ {"allowed_values": ["t1.micro", "m1.small", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge"], "description": "Must be a valid EC2 instance type."}, ] }, "LinuxDistribution": { "type": "string", "description": "Distribution of choice", "required": False, 'update_allowed': True, "constraints": [ {"allowed_values": ["F18", "F17", "U10", "RHEL-6.1", "RHEL-6.2", "RHEL-6.3"], "description": "Must be a valid Linux distribution"} ] }, "DBName": { "type": "string", "description": "The WordPress database name", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 64}, "description": "Length must be between 1 and 64"}, {"allowed_pattern": "[a-zA-Z][a-zA-Z0-9]*", "description": ("Must begin with a letter and contain " "only alphanumeric characters.")}, ] }, "DBUsername": { "type": "string", "description": "The WordPress database admin account username", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 16}, "description": "Length must be between 1 and 16"}, {"allowed_pattern": "[a-zA-Z][a-zA-Z0-9]*", "description": ("Must begin with a letter and only " "contain alphanumeric characters")}, ] }, "DBPassword": { "type": "string", "description": "The WordPress database admin account password", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 41}, "description": "Length must be between 1 and 41"}, {"allowed_pattern": "[a-zA-Z0-9]*", "description": ("Must contain only alphanumeric " "characters")}, ] }, "DBRootPassword": { "type": "string", "description": "Root password for MySQL", "required": False, 'update_allowed': True, "constraints": [ {"length": {"min": 1, "max": 41}, "description": "Length must be between 1 and 41"}, {"allowed_pattern": "[a-zA-Z0-9]*", "description": ("Must contain only alphanumeric " "characters")}, ] } } params = dict((n, hot_param.HOTParamSchema.from_dict(s)) for n, s in params_snippet.items()) props_schemata = properties.Properties.schema_from_params(params) self.assertEqual(expected, dict((n, dict(s)) for n, s in props_schemata.items())) class PropertiesValidationTest(testtools.TestCase): def test_required(self): schema = {'foo': {'Type': 'String', 'Required': True}} props = properties.Properties(schema, {'foo': 'bar'}) self.assertIsNone(props.validate()) def test_missing_required(self): schema = {'foo': {'Type': 'String', 'Required': True}} props = properties.Properties(schema, {}) self.assertRaises(exception.StackValidationFailed, props.validate) def test_missing_unimplemented(self): schema = {'foo': {'Type': 'String', 'Implemented': False}} props = properties.Properties(schema, {}) self.assertIsNone(props.validate()) def test_present_unimplemented(self): schema = {'foo': {'Type': 'String', 'Implemented': False}} props = properties.Properties(schema, {'foo': 'bar'}) self.assertRaises(exception.StackValidationFailed, props.validate) def test_missing(self): schema = {'foo': {'Type': 'String'}} props = properties.Properties(schema, {}) self.assertIsNone(props.validate()) def test_bad_data(self): schema = {'foo': {'Type': 'String'}} props = properties.Properties(schema, {'foo': 42}) self.assertRaises(exception.StackValidationFailed, props.validate) def test_unknown_typo(self): schema = {'foo': {'Type': 'String'}} props = properties.Properties(schema, {'food': 42}) self.assertRaises(exception.StackValidationFailed, props.validate) def test_none_string(self): schema = {'foo': {'Type': 'String'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_integer(self): schema = {'foo': {'Type': 'Integer'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_number(self): schema = {'foo': {'Type': 'Number'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_boolean(self): schema = {'foo': {'Type': 'Boolean'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_map(self): schema = {'foo': {'Type': 'Map'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_list(self): schema = {'foo': {'Type': 'List'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_default_string(self): schema = {'foo': {'Type': 'String', 'Default': 'bar'}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_default_integer(self): schema = {'foo': {'Type': 'Integer', 'Default': 42}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_default_number(self): schema = {'foo': {'Type': 'Number', 'Default': 42.0}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_default_boolean(self): schema = {'foo': {'Type': 'Boolean', 'Default': True}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_default_map(self): schema = {'foo': {'Type': 'Map', 'Default': {'bar': 'baz'}}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_none_default_list(self): schema = {'foo': {'Type': 'List', 'Default': ['one', 'two']}} props = properties.Properties(schema, {'foo': None}) self.assertIsNone(props.validate()) def test_schema_to_template_nested_map_map_schema(self): nested_schema = {'Key': {'Type': 'String', 'Required': True}, 'Value': {'Type': 'String', 'Required': True, 'Default': 'fewaf'}} schema = {'foo': {'Type': 'Map', 'Schema': nested_schema}} prop_expected = {'foo': {'Ref': 'foo'}} param_expected = {'foo': {'Type': 'Json'}} (parameters, props) = \ properties.Properties.schema_to_parameters_and_properties(schema) self.assertEqual(param_expected, parameters) self.assertEqual(prop_expected, props) def test_schema_to_template_nested_map_list_map_schema(self): key_schema = {'bar': {'Type': 'Number'}} nested_schema = {'Key': {'Type': 'Map', 'Schema': key_schema}, 'Value': {'Type': 'String', 'Required': True}} schema = {'foo': {'Type': 'List', 'Schema': {'Type': 'Map', 'Schema': nested_schema}}} prop_expected = {'foo': {'Fn::Split': [",", {'Ref': 'foo'}]}} param_expected = {'foo': {'Type': 'CommaDelimitedList'}} (parameters, props) = \ properties.Properties.schema_to_parameters_and_properties(schema) self.assertEqual(param_expected, parameters) self.assertEqual(prop_expected, props) def test_schema_object_to_template_nested_map_list_map_schema(self): key_schema = {'bar': properties.Schema(properties.Schema.NUMBER)} nested_schema = { 'Key': properties.Schema(properties.Schema.MAP, schema=key_schema), 'Value': properties.Schema(properties.Schema.STRING, required=True) } schema = { 'foo': properties.Schema(properties.Schema.LIST, schema=properties.Schema( properties.Schema.MAP, schema=nested_schema)) } prop_expected = {'foo': {'Fn::Split': [",", {'Ref': 'foo'}]}} param_expected = {'foo': {'Type': 'CommaDelimitedList'}} (parameters, props) = \ properties.Properties.schema_to_parameters_and_properties(schema) self.assertEqual(param_expected, parameters) self.assertEqual(prop_expected, props) def test_schema_invalid_parameters_stripped(self): schema = {'foo': {'Type': 'String', 'Required': True, 'Implemented': True}} prop_expected = {'foo': {'Ref': 'foo'}} param_expected = {'foo': {'Type': 'String'}} (parameters, props) = \ properties.Properties.schema_to_parameters_and_properties(schema) self.assertEqual(param_expected, parameters) self.assertEqual(prop_expected, props) def test_schema_support_status(self): schema = { 'foo_sup': properties.Schema( properties.Schema.STRING, default='foo' ), 'bar_dep': properties.Schema( properties.Schema.STRING, default='bar', support_status=support.SupportStatus( support.DEPRECATED, 'Do not use this ever') ) } props = properties.Properties(schema, {}) self.assertEqual(props.props['foo_sup'].support_status().status, support.SUPPORTED) self.assertEqual(props.props['bar_dep'].support_status().status, support.DEPRECATED) self.assertEqual(props.props['bar_dep'].support_status().message, 'Do not use this ever') def test_nested_properties_schema_invalid_property_in_list(self): child_schema = {'Key': {'Type': 'String', 'Required': True}, 'Value': {'Type': 'Boolean', 'Required': True, 'Default': True}} list_schema = {'Type': 'Map', 'Schema': child_schema} schema = {'foo': {'Type': 'List', 'Schema': list_schema}} valid_data = {'foo': [{'Key': 'Test'}]} props = properties.Properties(schema, valid_data) self.assertIsNone(props.validate()) invalid_data = {'foo': [{'Key': 'Test', 'bar': 'baz'}]} props = properties.Properties(schema, invalid_data) ex = self.assertRaises(exception.StackValidationFailed, props.validate) self.assertEqual('Property error : foo Property error : foo: 0 ' 'Unknown Property bar', str(ex)) def test_nested_properties_schema_invalid_property_in_map(self): child_schema = {'Key': {'Type': 'String', 'Required': True}, 'Value': {'Type': 'Boolean', 'Required': True, 'Default': True}} map_schema = {'boo': {'Type': 'Map', 'Schema': child_schema}} schema = {'foo': {'Type': 'Map', 'Schema': map_schema}} valid_data = {'foo': {'boo': {'Key': 'Test'}}} props = properties.Properties(schema, valid_data) self.assertIsNone(props.validate()) invalid_data = {'foo': {'boo': {'Key': 'Test', 'bar': 'baz'}}} props = properties.Properties(schema, invalid_data) ex = self.assertRaises(exception.StackValidationFailed, props.validate) self.assertEqual('Property error : foo Property error : foo: boo ' 'Unknown Property bar', str(ex)) def test_more_nested_properties_schema_invalid_property_in_list(self): nested_child_schema = {'Key': {'Type': 'String', 'Required': True}} child_schema = {'doo': {'Type': 'Map', 'Schema': nested_child_schema}} list_schema = {'Type': 'Map', 'Schema': child_schema} schema = {'foo': {'Type': 'List', 'Schema': list_schema}} valid_data = {'foo': [{'doo': {'Key': 'Test'}}]} props = properties.Properties(schema, valid_data) self.assertIsNone(props.validate()) invalid_data = {'foo': [{'doo': {'Key': 'Test', 'bar': 'baz'}}]} props = properties.Properties(schema, invalid_data) ex = self.assertRaises(exception.StackValidationFailed, props.validate) self.assertEqual('Property error : foo Property error : foo: 0 ' 'Property error : 0: doo Unknown Property bar', str(ex)) def test_more_nested_properties_schema_invalid_property_in_map(self): nested_child_schema = {'Key': {'Type': 'String', 'Required': True}} child_schema = {'doo': {'Type': 'Map', 'Schema': nested_child_schema}} map_schema = {'boo': {'Type': 'Map', 'Schema': child_schema}} schema = {'foo': {'Type': 'Map', 'Schema': map_schema}} valid_data = {'foo': {'boo': {'doo': {'Key': 'Test'}}}} props = properties.Properties(schema, valid_data) self.assertIsNone(props.validate()) invalid_data = {'foo': {'boo': {'doo': {'Key': 'Test', 'bar': 'baz'}}}} props = properties.Properties(schema, invalid_data) ex = self.assertRaises(exception.StackValidationFailed, props.validate) self.assertEqual('Property error : foo Property error : foo: boo ' 'Property error : boo: doo Unknown Property bar', str(ex)) heat-2014.1.5/heat/tests/test_neutron_firewall.py0000664000567000056700000004344112540642614023112 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. import copy from testtools import skipIf from heat.common import exception from heat.common import template_format from heat.engine import clients from heat.engine.resources.neutron import firewall from heat.engine import scheduler from heat.openstack.common.importutils import try_import from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils neutronclient = try_import('neutronclient.v2_0.client') firewall_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test neutron firewall resource", "Parameters" : {}, "Resources" : { "firewall": { "Type": "OS::Neutron::Firewall", "Properties": { "name": "test-firewall", "firewall_policy_id": "policy-id", "admin_state_up": True, } } } } ''' firewall_policy_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test neutron firewall policy resource", "Parameters" : {}, "Resources" : { "firewall_policy": { "Type": "OS::Neutron::FirewallPolicy", "Properties": { "name": "test-firewall-policy", "shared": True, "audited": True, "firewall_rules": ['rule-id-1', 'rule-id-2'], } } } } ''' firewall_rule_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Template to test neutron firewall rule resource", "Parameters" : {}, "Resources" : { "firewall_rule": { "Type": "OS::Neutron::FirewallRule", "Properties": { "name": "test-firewall-rule", "shared": True, "protocol": "tcp", "action": "allow", "enabled": True, "ip_version": "4", } } } } ''' @skipIf(neutronclient is None, 'neutronclient unavailable') class FirewallTest(HeatTestCase): def setUp(self): super(FirewallTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_firewall') self.m.StubOutWithMock(neutronclient.Client, 'delete_firewall') self.m.StubOutWithMock(neutronclient.Client, 'show_firewall') self.m.StubOutWithMock(neutronclient.Client, 'update_firewall') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_firewall(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_firewall({ 'firewall': { 'name': 'test-firewall', 'admin_state_up': True, 'firewall_policy_id': 'policy-id'}} ).AndReturn({'firewall': {'id': '5678'}}) snippet = template_format.parse(firewall_template) stack = utils.parse_stack(snippet) return firewall.Firewall( 'firewall', snippet['Resources']['firewall'], stack) def test_create(self): rsrc = self.create_firewall() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_firewall({ 'firewall': { 'name': 'test-firewall', 'admin_state_up': True, 'firewall_policy_id': 'policy-id'}} ).AndRaise(firewall.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(firewall_template) stack = utils.parse_stack(snippet) rsrc = firewall.Firewall( 'firewall', snippet['Resources']['firewall'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete(self): neutronclient.Client.delete_firewall('5678') neutronclient.Client.show_firewall('5678').AndRaise( firewall.NeutronClientException(status_code=404)) rsrc = self.create_firewall() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_firewall('5678').AndRaise( firewall.NeutronClientException(status_code=404)) rsrc = self.create_firewall() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_firewall('5678').AndRaise( firewall.NeutronClientException(status_code=400)) rsrc = self.create_firewall() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_firewall() neutronclient.Client.show_firewall('5678').MultipleTimes( ).AndReturn( {'firewall': {'admin_state_up': True, 'firewall_policy_id': 'policy-id'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertIs(True, rsrc.FnGetAtt('admin_state_up')) self.assertEqual('policy-id', rsrc.FnGetAtt('firewall_policy_id')) self.m.VerifyAll() def test_attribute_failed(self): rsrc = self.create_firewall() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'subnet_id') self.assertEqual( 'The Referenced Attribute (firewall subnet_id) is ' 'incorrect.', str(error)) self.m.VerifyAll() def test_update(self): rsrc = self.create_firewall() neutronclient.Client.update_firewall( '5678', {'firewall': {'admin_state_up': False}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['admin_state_up'] = False scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class FirewallPolicyTest(HeatTestCase): def setUp(self): super(FirewallPolicyTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_firewall_policy') self.m.StubOutWithMock(neutronclient.Client, 'delete_firewall_policy') self.m.StubOutWithMock(neutronclient.Client, 'show_firewall_policy') self.m.StubOutWithMock(neutronclient.Client, 'update_firewall_policy') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_firewall_policy(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_firewall_policy({ 'firewall_policy': { 'name': 'test-firewall-policy', 'shared': True, 'audited': True, 'firewall_rules': ['rule-id-1', 'rule-id-2']}} ).AndReturn({'firewall_policy': {'id': '5678'}}) snippet = template_format.parse(firewall_policy_template) stack = utils.parse_stack(snippet) return firewall.FirewallPolicy( 'firewall_policy', snippet['Resources']['firewall_policy'], stack) def test_create(self): rsrc = self.create_firewall_policy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_firewall_policy({ 'firewall_policy': { 'name': 'test-firewall-policy', 'shared': True, 'audited': True, 'firewall_rules': ['rule-id-1', 'rule-id-2']}} ).AndRaise(firewall.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(firewall_policy_template) stack = utils.parse_stack(snippet) rsrc = firewall.FirewallPolicy( 'firewall_policy', snippet['Resources']['firewall_policy'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete(self): neutronclient.Client.delete_firewall_policy('5678') neutronclient.Client.show_firewall_policy('5678').AndRaise( firewall.NeutronClientException(status_code=404)) rsrc = self.create_firewall_policy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_firewall_policy('5678').AndRaise( firewall.NeutronClientException(status_code=404)) rsrc = self.create_firewall_policy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_firewall_policy('5678').AndRaise( firewall.NeutronClientException(status_code=400)) rsrc = self.create_firewall_policy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_firewall_policy() neutronclient.Client.show_firewall_policy('5678').MultipleTimes( ).AndReturn( {'firewall_policy': {'audited': True, 'shared': True}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertIs(True, rsrc.FnGetAtt('audited')) self.assertIs(True, rsrc.FnGetAtt('shared')) self.m.VerifyAll() def test_attribute_failed(self): rsrc = self.create_firewall_policy() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'subnet_id') self.assertEqual( 'The Referenced Attribute (firewall_policy subnet_id) is ' 'incorrect.', str(error)) self.m.VerifyAll() def test_update(self): rsrc = self.create_firewall_policy() neutronclient.Client.update_firewall_policy( '5678', {'firewall_policy': {'firewall_rules': ['3', '4']}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['firewall_rules'] = ['3', '4'] scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() @skipIf(neutronclient is None, 'neutronclient unavailable') class FirewallRuleTest(HeatTestCase): def setUp(self): super(FirewallRuleTest, self).setUp() self.m.StubOutWithMock(neutronclient.Client, 'create_firewall_rule') self.m.StubOutWithMock(neutronclient.Client, 'delete_firewall_rule') self.m.StubOutWithMock(neutronclient.Client, 'show_firewall_rule') self.m.StubOutWithMock(neutronclient.Client, 'update_firewall_rule') self.m.StubOutWithMock(clients.OpenStackClients, 'keystone') utils.setup_dummy_db() def create_firewall_rule(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_firewall_rule({ 'firewall_rule': { 'name': 'test-firewall-rule', 'shared': True, 'action': 'allow', 'protocol': 'tcp', 'enabled': True, 'ip_version': "4"}} ).AndReturn({'firewall_rule': {'id': '5678'}}) snippet = template_format.parse(firewall_rule_template) stack = utils.parse_stack(snippet) return firewall.FirewallRule( 'firewall_rule', snippet['Resources']['firewall_rule'], stack) def test_create(self): rsrc = self.create_firewall_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_firewall_rule({ 'firewall_rule': { 'name': 'test-firewall-rule', 'shared': True, 'action': 'allow', 'protocol': 'tcp', 'enabled': True, 'ip_version': "4"}} ).AndRaise(firewall.NeutronClientException()) self.m.ReplayAll() snippet = template_format.parse(firewall_rule_template) stack = utils.parse_stack(snippet) rsrc = firewall.FirewallRule( 'firewall_rule', snippet['Resources']['firewall_rule'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_delete(self): neutronclient.Client.delete_firewall_rule('5678') neutronclient.Client.show_firewall_rule('5678').AndRaise( firewall.NeutronClientException(status_code=404)) rsrc = self.create_firewall_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_already_gone(self): neutronclient.Client.delete_firewall_rule('5678').AndRaise( firewall.NeutronClientException(status_code=404)) rsrc = self.create_firewall_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_delete_failed(self): neutronclient.Client.delete_firewall_rule('5678').AndRaise( firewall.NeutronClientException(status_code=400)) rsrc = self.create_firewall_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.delete)) self.assertEqual( 'NeutronClientException: An unknown exception occurred.', str(error)) self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state) self.m.VerifyAll() def test_attribute(self): rsrc = self.create_firewall_rule() neutronclient.Client.show_firewall_rule('5678').MultipleTimes( ).AndReturn( {'firewall_rule': {'protocol': 'tcp', 'shared': True}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('tcp', rsrc.FnGetAtt('protocol')) self.assertIs(True, rsrc.FnGetAtt('shared')) self.m.VerifyAll() def test_attribute_failed(self): rsrc = self.create_firewall_rule() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'subnet_id') self.assertEqual( 'The Referenced Attribute (firewall_rule subnet_id) is ' 'incorrect.', str(error)) self.m.VerifyAll() def test_update(self): rsrc = self.create_firewall_rule() neutronclient.Client.update_firewall_rule( '5678', {'firewall_rule': {'protocol': 'icmp'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) update_template['Properties']['protocol'] = 'icmp' scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() heat-2014.1.5/heat/tests/test_common_policy.py0000664000567000056700000001567212540642614022407 0ustar jenkinsjenkins00000000000000# Copyright 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. import os.path from oslo.config import cfg from heat.common import exception from heat.common import policy from heat.openstack.common import policy as base_policy from heat.tests.common import HeatTestCase from heat.tests import utils policy_path = os.path.dirname(os.path.realpath(__file__)) + "/policy/" class TestPolicyEnforcer(HeatTestCase): cfn_actions = ("ListStacks", "CreateStack", "DescribeStacks", "DeleteStack", "UpdateStack", "DescribeStackEvents", "ValidateTemplate", "GetTemplate", "EstimateTemplateCost", "DescribeStackResource", "DescribeStackResources") cw_actions = ("DeleteAlarms", "DescribeAlarmHistory", "DescribeAlarms", "DescribeAlarmsForMetric", "DisableAlarmActions", "EnableAlarmActions", "GetMetricStatistics", "ListMetrics", "PutMetricAlarm", "PutMetricData", "SetAlarmState") def setUp(self): super(TestPolicyEnforcer, self).setUp() opts = [ cfg.StrOpt('config_dir', default=policy_path), cfg.StrOpt('config_file', default='foo'), cfg.StrOpt('project', default='heat'), ] cfg.CONF.register_opts(opts) self.addCleanup(self.m.VerifyAll) def stub_policyfile(self, filename): pf = policy_path + filename self.m.StubOutWithMock(base_policy.Enforcer, '_get_policy_path') base_policy.Enforcer._get_policy_path().MultipleTimes().AndReturn(pf) self.m.ReplayAll() def test_policy_cfn_default(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer(scope='cloudformation') ctx = utils.dummy_context(roles=[]) for action in self.cfn_actions: # Everything should be allowed enforcer.enforce(ctx, action) def test_policy_cfn_notallowed(self): self.stub_policyfile('notallowed.json') enforcer = policy.Enforcer(scope='cloudformation') ctx = utils.dummy_context(roles=[]) for action in self.cfn_actions: # Everything should raise the default exception.Forbidden self.assertRaises(exception.Forbidden, enforcer.enforce, ctx, action, {}) def test_policy_cfn_deny_stack_user(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer(scope='cloudformation') ctx = utils.dummy_context(roles=['heat_stack_user']) for action in self.cfn_actions: # Everything apart from DescribeStackResource should be Forbidden if action == "DescribeStackResource": enforcer.enforce(ctx, action) else: self.assertRaises(exception.Forbidden, enforcer.enforce, ctx, action, {}) def test_policy_cfn_allow_non_stack_user(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer(scope='cloudformation') ctx = utils.dummy_context(roles=['not_a_stack_user']) for action in self.cfn_actions: # Everything should be allowed enforcer.enforce(ctx, action) def test_policy_cw_deny_stack_user(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer(scope='cloudwatch') ctx = utils.dummy_context(roles=['heat_stack_user']) for action in self.cw_actions: # Everything apart from PutMetricData should be Forbidden if action == "PutMetricData": enforcer.enforce(ctx, action) else: self.assertRaises(exception.Forbidden, enforcer.enforce, ctx, action, {}) def test_policy_cw_allow_non_stack_user(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer(scope='cloudwatch') ctx = utils.dummy_context(roles=['not_a_stack_user']) for action in self.cw_actions: # Everything should be allowed enforcer.enforce(ctx, action) def test_clear(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer() enforcer.load_rules(force_reload=True) enforcer.clear() self.assertEqual({}, enforcer.enforcer.rules) def test_set_rules_overwrite_true(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer() enforcer.load_rules(True) enforcer.set_rules({'test_heat_rule': 1}, True) self.assertEqual({'test_heat_rule': 1}, enforcer.enforcer.rules) def test_set_rules_overwrite_false(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer() enforcer.load_rules(True) enforcer.set_rules({'test_heat_rule': 1}, False) self.assertIn('test_heat_rule', enforcer.enforcer.rules) def test_load_rules_force_reload_true(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer() enforcer.set_rules({'test_heat_rule': 'test'}) enforcer.load_rules(True) self.assertNotIn({'test_heat_rule': 'test'}, enforcer.enforcer.rules) def test_load_rules_force_reload_false(self): self.stub_policyfile('deny_stack_user.json') enforcer = policy.Enforcer() enforcer.load_rules(True) enforcer.set_rules({'test_heat_rule': 'test'}) enforcer.load_rules(False) self.assertIn('test_heat_rule', enforcer.enforcer.rules) def test_default_rule(self): self.stub_policyfile('deny_stack_user.json') ctx = utils.dummy_context(roles=['not_a_stack_user']) default_rule = base_policy.FalseCheck() enforcer = policy.Enforcer(scope='cloudformation', exc=None, default_rule=default_rule) action = 'no_such_action' self.assertFalse(enforcer.enforce(ctx, action)) def test_check_admin(self): self.stub_policyfile('check_admin.json') enforcer = policy.Enforcer() ctx = utils.dummy_context(roles=[]) self.assertFalse(enforcer.check_is_admin(ctx)) ctx = utils.dummy_context(roles=['not_admin']) self.assertFalse(enforcer.check_is_admin(ctx)) ctx = utils.dummy_context(roles=['admin']) self.assertTrue(enforcer.check_is_admin(ctx)) heat-2014.1.5/heat/tests/test_fault_middleware.py0000664000567000056700000001445612540642614023047 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. from heat.common import exception as heat_exc from heat.openstack.common.rpc import common as rpc_common from heat.tests.common import HeatTestCase from oslo.config import cfg import heat.api.middleware.fault as fault class StackNotFoundChild(heat_exc.StackNotFound): pass class FaultMiddlewareTest(HeatTestCase): def test_openstack_exception_with_kwargs(self): wrapper = fault.FaultWrapper(None) msg = wrapper._error(heat_exc.StackNotFound(stack_name='a')) expected = {'code': 404, 'error': {'message': 'The Stack (a) could not be found.', 'traceback': None, 'type': 'StackNotFound'}, 'explanation': 'The resource could not be found.', 'title': 'Not Found'} self.assertEqual(expected, msg) def test_openstack_exception_without_kwargs(self): wrapper = fault.FaultWrapper(None) msg = wrapper._error(heat_exc.StackResourceLimitExceeded()) expected = {'code': 500, 'error': {'message': 'Maximum resources ' 'per stack exceeded.', 'traceback': None, 'type': 'StackResourceLimitExceeded'}, 'explanation': 'The server has either erred or is ' 'incapable of performing the requested ' 'operation.', 'title': 'Internal Server Error'} self.assertEqual(expected, msg) def test_exception_with_non_ascii_chars(self): # We set debug to true to test the code path for serializing traces too cfg.CONF.set_override('debug', True) msg = u'Error with non-ascii chars \x80' class TestException(heat_exc.HeatException): msg_fmt = msg wrapper = fault.FaultWrapper(None) msg = wrapper._error(TestException()) expected = {'code': 500, 'error': {'message': u'Error with non-ascii chars \x80', 'traceback': 'None\n', 'type': 'TestException'}, 'explanation': ('The server has either erred or is ' 'incapable of performing the requested ' 'operation.'), 'title': 'Internal Server Error'} self.assertEqual(expected, msg) def test_remote_exception(self): # We want tracebacks cfg.CONF.set_override('debug', True) error = heat_exc.StackNotFound(stack_name='a') exc_info = (type(error), error, None) serialized = rpc_common.serialize_remote_exception(exc_info) remote_error = rpc_common.deserialize_remote_exception(cfg.CONF, serialized) wrapper = fault.FaultWrapper(None) msg = wrapper._error(remote_error) expected_message, expected_traceback = str(remote_error).split('\n', 1) expected = {'code': 404, 'error': {'message': expected_message, 'traceback': expected_traceback, 'type': 'StackNotFound'}, 'explanation': 'The resource could not be found.', 'title': 'Not Found'} self.assertEqual(expected, msg) def test_should_not_ignore_parent_classes(self): wrapper = fault.FaultWrapper(None) msg = wrapper._error(StackNotFoundChild(stack_name='a')) expected = {'code': 404, 'error': {'message': 'The Stack (a) could not be found.', 'traceback': None, 'type': 'StackNotFoundChild'}, 'explanation': 'The resource could not be found.', 'title': 'Not Found'} self.assertEqual(expected, msg) def test_internal_server_error_when_exeption_and_parents_not_mapped(self): wrapper = fault.FaultWrapper(None) class NotMappedException(Exception): pass msg = wrapper._error(NotMappedException('A message')) expected = {'code': 500, 'error': {'message': u'A message', 'traceback': None, 'type': 'NotMappedException'}, 'explanation': ('The server has either erred or is ' 'incapable of performing the requested ' 'operation.'), 'title': 'Internal Server Error'} self.assertEqual(expected, msg) def test_should_not_ignore_parent_classes_even_for_remote_ones(self): # We want tracebacks cfg.CONF.set_override('debug', True) cfg.CONF.set_override('allowed_rpc_exception_modules', ['heat.tests.test_fault_middleware']) error = StackNotFoundChild(stack_name='a') exc_info = (type(error), error, None) serialized = rpc_common.serialize_remote_exception(exc_info) remote_error = rpc_common.deserialize_remote_exception(cfg.CONF, serialized) wrapper = fault.FaultWrapper(None) msg = wrapper._error(remote_error) expected_message, expected_traceback = str(remote_error).split('\n', 1) expected = {'code': 404, 'error': {'message': expected_message, 'traceback': expected_traceback, 'type': 'StackNotFoundChild'}, 'explanation': 'The resource could not be found.', 'title': 'Not Found'} self.assertEqual(expected, msg) heat-2014.1.5/heat/tests/test_metadata_refresh.py0000664000567000056700000002437212540642614023033 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. import mox from oslo.config import cfg from heat.common import identifier from heat.common import template_format from heat.engine import environment from heat.engine import parser from heat.engine.resources import image from heat.engine.resources import instance from heat.engine.resources import nova_keypair from heat.engine.resources import wait_condition as wc from heat.engine import scheduler from heat.engine import service from heat.tests.common import HeatTestCase from heat.tests import fakes from heat.tests import utils test_template_metadata = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "", "Parameters" : { "KeyName" : {"Type" : "String", "Default": "mine" }, }, "Resources" : { "S1": { "Type": "AWS::EC2::Instance", "Metadata" : { "AWS::CloudFormation::Init" : { "config" : { "files" : { "/tmp/random_file" : { "content" : { "Fn::Join" : ["", [ "s2-ip=", {"Fn::GetAtt": ["S2", "PublicIp"]} ]]}, "mode" : "000400", "owner" : "root", "group" : "root" } } } } }, "Properties": { "ImageId" : "a", "InstanceType" : "m1.large", "KeyName" : { "Ref" : "KeyName" }, "UserData" : "#!/bin/bash -v\n" } }, "S2": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "a", "InstanceType" : "m1.large", "KeyName" : { "Ref" : "KeyName" }, "UserData" : "#!/bin/bash -v\n" } } } } ''' test_template_waitcondition = ''' { "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "Just a WaitCondition.", "Parameters" : { "KeyName" : {"Type" : "String", "Default": "mine" }, }, "Resources" : { "WH" : { "Type" : "AWS::CloudFormation::WaitConditionHandle" }, "S1": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "a", "InstanceType" : "m1.large", "KeyName" : { "Ref" : "KeyName" }, "UserData" : { "Fn::Join" : [ "", [ "#!/bin/bash -v\n", "echo ", { "Ref" : "WH" }, "\n" ] ] } } }, "WC" : { "Type" : "AWS::CloudFormation::WaitCondition", "DependsOn": "S1", "Properties" : { "Handle" : {"Ref" : "WH"}, "Timeout" : "5" } }, "S2": { "Type": "AWS::EC2::Instance", "Metadata" : { "test" : {"Fn::GetAtt": ["WC", "Data"]} }, "Properties": { "ImageId" : "a", "InstanceType" : "m1.large", "KeyName" : { "Ref" : "KeyName" }, "UserData" : "#!/bin/bash -v\n" } } } } ''' class MetadataRefreshTest(HeatTestCase): ''' The point of the test is to confirm that metadata gets updated when FnGetAtt() returns something different. gets called. ''' def setUp(self): super(MetadataRefreshTest, self).setUp() self.fc = fakes.FakeKeystoneClient() utils.setup_dummy_db() # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the stack is properly cleaned up def create_stack(self, stack_name='test_stack', params={}): temp = template_format.parse(test_template_metadata) template = parser.Template(temp) ctx = utils.dummy_context() stack = parser.Stack(ctx, stack_name, template, environment.Environment(params), disable_rollback=True) self.stack_id = stack.store() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') for cookie in (object(), object()): instance.Instance.handle_create().AndReturn(cookie) create_complete = instance.Instance.check_create_complete(cookie) create_complete.InAnyOrder().AndReturn(True) self.m.StubOutWithMock(instance.Instance, 'FnGetAtt') return stack @utils.stack_delete_after def test_FnGetAtt(self): self.stack = self.create_stack() instance.Instance.FnGetAtt('PublicIp').AndReturn('1.2.3.5') # called by metadata_update() instance.Instance.FnGetAtt('PublicIp').AndReturn('10.0.0.5') self.m.ReplayAll() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) s1 = self.stack['S1'] s2 = self.stack['S2'] files = s1.metadata['AWS::CloudFormation::Init']['config']['files'] cont = files['/tmp/random_file']['content'] self.assertEqual((s2.CREATE, s2.COMPLETE), s2.state) self.assertEqual('s2-ip=1.2.3.5', cont) s1.metadata_update() s2.metadata_update() files = s1.metadata['AWS::CloudFormation::Init']['config']['files'] cont = files['/tmp/random_file']['content'] self.assertEqual('s2-ip=10.0.0.5', cont) self.m.VerifyAll() class WaitCondMetadataUpdateTest(HeatTestCase): def setUp(self): super(WaitCondMetadataUpdateTest, self).setUp() utils.setup_dummy_db() self.fc = fakes.FakeKeystoneClient() self.m.StubOutWithMock(service.EngineListener, 'start') service.EngineListener.start().AndReturn(None) self.m.ReplayAll() self.man = service.EngineService('a-host', 'a-topic') cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') # Note tests creating a stack should be decorated with @stack_delete_after # to ensure the stack is properly cleaned up def create_stack(self, stack_name='test_stack'): temp = template_format.parse(test_template_waitcondition) template = parser.Template(temp) ctx = utils.dummy_context() stack = parser.Stack(ctx, stack_name, template, disable_rollback=True) self.stack_id = stack.store() self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate') nova_keypair.KeypairConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(image.ImageConstraint, 'validate') image.ImageConstraint.validate( mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True) self.m.StubOutWithMock(instance.Instance, 'handle_create') self.m.StubOutWithMock(instance.Instance, 'check_create_complete') for cookie in (object(), object()): instance.Instance.handle_create().AndReturn(cookie) instance.Instance.check_create_complete(cookie).AndReturn(True) self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn(self.fc) id = identifier.ResourceIdentifier('test_tenant_id', stack.name, stack.id, '', 'WH') self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier') wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id) self.m.StubOutWithMock(scheduler.TaskRunner, '_sleep') self.m.StubOutWithMock(service.EngineService, 'load_user_creds') service.EngineService.load_user_creds( mox.IgnoreArg()).MultipleTimes().AndReturn(ctx) return stack @utils.stack_delete_after def test_wait_meta(self): ''' 1 create stack 2 assert empty instance metadata 3 service.metadata_update() 4 assert valid waitcond metadata 5 assert valid instance metadata ''' self.stack = self.create_stack() watch = self.stack['WC'] inst = self.stack['S2'] def check_empty(sleep_time): self.assertEqual('{}', watch.FnGetAtt('Data')) self.assertIsNone(inst.metadata['test']) def update_metadata(id, data, reason): self.man.metadata_update(utils.dummy_context(), dict(self.stack.identifier()), 'WH', {'Data': data, 'Reason': reason, 'Status': 'SUCCESS', 'UniqueId': id}) def post_success(sleep_time): update_metadata('123', 'foo', 'bar') scheduler.TaskRunner._sleep(mox.IsA(int)).WithSideEffects(check_empty) scheduler.TaskRunner._sleep(mox.IsA(int)).WithSideEffects(post_success) scheduler.TaskRunner._sleep(mox.IsA(int)).MultipleTimes().AndReturn( None) self.m.ReplayAll() self.stack.create() self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), self.stack.state) self.assertEqual('{"123": "foo"}', watch.FnGetAtt('Data')) self.assertEqual('{"123": "foo"}', inst.metadata['test']) update_metadata('456', 'blarg', 'wibble') self.assertEqual('{"123": "foo", "456": "blarg"}', watch.FnGetAtt('Data')) self.assertEqual('{"123": "foo", "456": "blarg"}', inst.metadata['test']) self.m.VerifyAll() heat-2014.1.5/heat/tests/test_rpc_client.py0000664000567000056700000002532212540642614021653 0ustar jenkinsjenkins00000000000000 # Copyright 2012, Red Hat, Inc. # # 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. """ Unit Tests for heat.rpc.client """ import mock from oslo.config import cfg import stubout import testtools from heat.common import identifier from heat.openstack.common import rpc from heat.rpc import api as rpc_api from heat.rpc import client as rpc_client from heat.tests import utils class EngineRpcAPITestCase(testtools.TestCase): def setUp(self): self.context = utils.dummy_context() cfg.CONF.set_default('rpc_backend', 'heat.openstack.common.rpc.impl_fake') cfg.CONF.set_default('verbose', True) cfg.CONF.set_default('host', 'host') self.stubs = stubout.StubOutForTesting() self.identity = dict(identifier.HeatIdentifier('engine_test_tenant', '6', 'wordpress')) super(EngineRpcAPITestCase, self).setUp() def _test_engine_api(self, method, rpc_method, **kwargs): ctxt = utils.dummy_context() if 'rpcapi_class' in kwargs: rpcapi_class = kwargs['rpcapi_class'] del kwargs['rpcapi_class'] else: rpcapi_class = rpc_client.EngineClient rpcapi = rpcapi_class() expected_retval = 'foo' if method == 'call' else None expected_version = kwargs.pop('version', rpcapi.BASE_RPC_API_VERSION) expected_msg = rpcapi.make_msg(method, **kwargs) expected_msg['version'] = expected_version expected_topic = rpc_api.ENGINE_TOPIC cast_and_call = ['delete_stack'] if rpc_method == 'call' and method in cast_and_call: kwargs['cast'] = False with mock.patch.object(rpc, rpc_method) as mock_rpc_method: mock_rpc_method.return_value = expected_retval retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(expected_retval, retval) expected_args = [ctxt, expected_topic, expected_msg, mock.ANY] actual_args, _ = mock_rpc_method.call_args for expected_arg, actual_arg in zip(expected_args, actual_args): self.assertEqual(expected_arg, actual_arg) def test_authenticated_to_backend(self): self._test_engine_api('authenticated_to_backend', 'call') def test_list_stacks(self): default_args = { 'limit': mock.ANY, 'sort_keys': mock.ANY, 'marker': mock.ANY, 'sort_dir': mock.ANY, 'filters': mock.ANY, 'tenant_safe': mock.ANY, } self._test_engine_api('list_stacks', 'call', **default_args) def test_count_stacks(self): default_args = { 'filters': mock.ANY, 'tenant_safe': mock.ANY, } self._test_engine_api('count_stacks', 'call', **default_args) def test_identify_stack(self): self._test_engine_api('identify_stack', 'call', stack_name='wordpress') def test_show_stack(self): self._test_engine_api('show_stack', 'call', stack_identity='wordpress') def test_preview_stack(self): self._test_engine_api('preview_stack', 'call', stack_name='wordpress', template={u'Foo': u'bar'}, params={u'InstanceType': u'm1.xlarge'}, files={u'a_file': u'the contents'}, args={'timeout_mins': u'30'}) def test_create_stack(self): self._test_engine_api('create_stack', 'call', stack_name='wordpress', template={u'Foo': u'bar'}, params={u'InstanceType': u'm1.xlarge'}, files={u'a_file': u'the contents'}, args={'timeout_mins': u'30'}) def test_update_stack(self): self._test_engine_api('update_stack', 'call', stack_identity=self.identity, template={u'Foo': u'bar'}, params={u'InstanceType': u'm1.xlarge'}, files={}, args=mock.ANY) def test_get_template(self): self._test_engine_api('get_template', 'call', stack_identity=self.identity) def test_delete_stack_cast(self): self._test_engine_api('delete_stack', 'cast', stack_identity=self.identity) def test_delete_stack_call(self): self._test_engine_api('delete_stack', 'call', stack_identity=self.identity) def test_validate_template(self): self._test_engine_api('validate_template', 'call', template={u'Foo': u'bar'}, params={u'Egg': u'spam'}) def test_list_resource_types(self): self._test_engine_api('list_resource_types', 'call', support_status=None, version='1.1') def test_resource_schema(self): self._test_engine_api('resource_schema', 'call', type_name="TYPE") def test_generate_template(self): self._test_engine_api('generate_template', 'call', type_name="TYPE") def test_list_events(self): self._test_engine_api('list_events', 'call', stack_identity=self.identity) def test_describe_stack_resource(self): self._test_engine_api('describe_stack_resource', 'call', stack_identity=self.identity, resource_name='LogicalResourceId') def test_find_physical_resource(self): self._test_engine_api('find_physical_resource', 'call', physical_resource_id=u'404d-a85b-5315293e67de') def test_describe_stack_resources(self): self._test_engine_api('describe_stack_resources', 'call', stack_identity=self.identity, resource_name=u'WikiDatabase') def test_list_stack_resources(self): self._test_engine_api('list_stack_resources', 'call', stack_identity=self.identity) def test_stack_suspend(self): self._test_engine_api('stack_suspend', 'call', stack_identity=self.identity) def test_stack_resume(self): self._test_engine_api('stack_resume', 'call', stack_identity=self.identity) def test_metadata_update(self): self._test_engine_api('metadata_update', 'call', stack_identity=self.identity, resource_name='LogicalResourceId', metadata={u'wordpress': []}) def test_resource_signal(self): self._test_engine_api('resource_signal', 'call', stack_identity=self.identity, resource_name='LogicalResourceId', details={u'wordpress': []}) def test_create_watch_data(self): self._test_engine_api('create_watch_data', 'call', watch_name='watch1', stats_data={}) def test_show_watch(self): self._test_engine_api('show_watch', 'call', watch_name='watch1') def test_show_watch_metric(self): self._test_engine_api('show_watch_metric', 'call', metric_namespace=None, metric_name=None) def test_set_watch_state(self): self._test_engine_api('set_watch_state', 'call', watch_name='watch1', state="xyz") def test_show_software_config(self): self._test_engine_api('show_software_config', 'call', config_id='cda89008-6ea6-4057-b83d-ccde8f0b48c9') def test_create_software_config(self): self._test_engine_api('create_software_config', 'call', group='Heat::Shell', name='config_mysql', config='#!/bin/bash', inputs=[], outputs=[], options={}) def test_delete_software_config(self): self._test_engine_api('delete_software_config', 'call', config_id='cda89008-6ea6-4057-b83d-ccde8f0b48c9') def test_list_software_deployments(self): self._test_engine_api('list_software_deployments', 'call', server_id=None) self._test_engine_api('list_software_deployments', 'call', server_id='9dc13236-d342-451f-a885-1c82420ba5ed') def test_show_software_deployment(self): deployment_id = '86729f02-4648-44d8-af44-d0ec65b6abc9' self._test_engine_api('show_software_deployment', 'call', deployment_id=deployment_id) def test_create_software_deployment(self): self._test_engine_api( 'create_software_deployment', 'call', server_id='9f1f0e00-05d2-4ca5-8602-95021f19c9d0', config_id='48e8ade1-9196-42d5-89a2-f709fde42632', stack_user_project_id='65728b74-cfe7-4f17-9c15-11d4f686e591', input_values={}, action='INIT', status='COMPLETE', status_reason=None) def test_update_software_deployment(self): deployment_id = '86729f02-4648-44d8-af44-d0ec65b6abc9' self._test_engine_api('update_software_deployment', 'call', deployment_id=deployment_id, config_id='48e8ade1-9196-42d5-89a2-f709fde42632', input_values={}, output_values={}, action='DEPLOYED', status='COMPLETE', status_reason=None) def test_delete_software_deployment(self): deployment_id = '86729f02-4648-44d8-af44-d0ec65b6abc9' self._test_engine_api('delete_software_deployment', 'call', deployment_id=deployment_id) heat-2014.1.5/heat/rpc/0000775000567000056700000000000012540643116015534 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/rpc/__init__.py0000664000567000056700000000000012540642611017632 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/rpc/api.py0000664000567000056700000001525312540642614016667 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. ENGINE_TOPIC = 'engine' PARAM_KEYS = ( PARAM_TIMEOUT, PARAM_DISABLE_ROLLBACK, PARAM_ADOPT_STACK_DATA ) = ( 'timeout_mins', 'disable_rollback', 'adopt_stack_data' ) STACK_KEYS = ( STACK_NAME, STACK_ID, STACK_CREATION_TIME, STACK_UPDATED_TIME, STACK_DELETION_TIME, STACK_NOTIFICATION_TOPICS, STACK_DESCRIPTION, STACK_TMPL_DESCRIPTION, STACK_PARAMETERS, STACK_OUTPUTS, STACK_ACTION, STACK_STATUS, STACK_STATUS_DATA, STACK_CAPABILITIES, STACK_DISABLE_ROLLBACK, STACK_TIMEOUT, ) = ( 'stack_name', 'stack_identity', 'creation_time', 'updated_time', 'deletion_time', 'notification_topics', 'description', 'template_description', 'parameters', 'outputs', 'stack_action', 'stack_status', 'stack_status_reason', 'capabilities', 'disable_rollback', 'timeout_mins', ) STACK_OUTPUT_KEYS = ( OUTPUT_DESCRIPTION, OUTPUT_KEY, OUTPUT_VALUE, ) = ( 'description', 'output_key', 'output_value', ) RES_KEYS = ( RES_DESCRIPTION, RES_UPDATED_TIME, RES_NAME, RES_PHYSICAL_ID, RES_METADATA, RES_ACTION, RES_STATUS, RES_STATUS_DATA, RES_TYPE, RES_ID, RES_STACK_ID, RES_STACK_NAME, RES_REQUIRED_BY, ) = ( 'description', 'updated_time', 'resource_name', 'physical_resource_id', 'metadata', 'resource_action', 'resource_status', 'resource_status_reason', 'resource_type', 'resource_identity', STACK_ID, STACK_NAME, 'required_by', ) RES_SCHEMA_KEYS = ( RES_SCHEMA_RES_TYPE, RES_SCHEMA_PROPERTIES, RES_SCHEMA_ATTRIBUTES, ) = ( RES_TYPE, 'properties', 'attributes', ) EVENT_KEYS = ( EVENT_ID, EVENT_STACK_ID, EVENT_STACK_NAME, EVENT_TIMESTAMP, EVENT_RES_NAME, EVENT_RES_PHYSICAL_ID, EVENT_RES_ACTION, EVENT_RES_STATUS, EVENT_RES_STATUS_DATA, EVENT_RES_TYPE, EVENT_RES_PROPERTIES, ) = ( 'event_identity', STACK_ID, STACK_NAME, 'event_time', RES_NAME, RES_PHYSICAL_ID, RES_ACTION, RES_STATUS, RES_STATUS_DATA, RES_TYPE, 'resource_properties', ) NOTIFY_KEYS = ( NOTIFY_TENANT_ID, NOTIFY_USER_ID, NOTIFY_STACK_ID, NOTIFY_STACK_NAME, NOTIFY_STATE, NOTIFY_STATE_REASON, NOTIFY_CREATE_AT, ) = ( 'tenant_id', 'user_id', STACK_ID, STACK_NAME, 'state', 'state_reason', 'create_at', ) # This is the representation of a watch we expose to the API via RPC WATCH_KEYS = ( WATCH_ACTIONS_ENABLED, WATCH_ALARM_ACTIONS, WATCH_TOPIC, WATCH_UPDATED_TIME, WATCH_DESCRIPTION, WATCH_NAME, WATCH_COMPARISON, WATCH_DIMENSIONS, WATCH_PERIODS, WATCH_INSUFFICIENT_ACTIONS, WATCH_METRIC_NAME, WATCH_NAMESPACE, WATCH_OK_ACTIONS, WATCH_PERIOD, WATCH_STATE_REASON, WATCH_STATE_REASON_DATA, WATCH_STATE_UPDATED_TIME, WATCH_STATE_VALUE, WATCH_STATISTIC, WATCH_THRESHOLD, WATCH_UNIT, WATCH_STACK_ID, ) = ( 'actions_enabled', 'actions', 'topic', 'updated_time', 'description', 'name', 'comparison', 'dimensions', 'periods', 'insufficient_actions', 'metric_name', 'namespace', 'ok_actions', 'period', 'state_reason', 'state_reason_data', 'state_updated_time', 'state_value', 'statistic', 'threshold', 'unit', 'stack_id', ) # Alternate representation of a watch rule to align with DB format # FIXME : These align with AWS naming for compatibility with the # current cfn-push-stats & metadata server, fix when we've ported # cfn-push-stats to use the Cloudwatch server and/or moved metric # collection into ceilometer, these should just be WATCH_KEYS # or each field should be stored separately in the DB watch_data # table if we stick to storing watch data in the heat DB WATCH_RULE_KEYS = ( RULE_ACTIONS_ENABLED, RULE_ALARM_ACTIONS, RULE_TOPIC, RULE_UPDATED_TIME, RULE_DESCRIPTION, RULE_NAME, RULE_COMPARISON, RULE_DIMENSIONS, RULE_PERIODS, RULE_INSUFFICIENT_ACTIONS, RULE_METRIC_NAME, RULE_NAMESPACE, RULE_OK_ACTIONS, RULE_PERIOD, RULE_STATE_REASON, RULE_STATE_REASON_DATA, RULE_STATE_UPDATED_TIME, RULE_STATE_VALUE, RULE_STATISTIC, RULE_THRESHOLD, RULE_UNIT, RULE_STACK_NAME, ) = ( 'ActionsEnabled', 'AlarmActions', 'AlarmArn', 'AlarmConfigurationUpdatedTimestamp', 'AlarmDescription', 'AlarmName', 'ComparisonOperator', 'Dimensions', 'EvaluationPeriods', 'InsufficientDataActions', 'MetricName', 'Namespace', 'OKActions', 'Period', 'StateReason', 'StateReasonData', 'StateUpdatedTimestamp', 'StateValue', 'Statistic', 'Threshold', 'Unit', 'StackName', ) WATCH_STATES = ( WATCH_STATE_OK, WATCH_STATE_ALARM, WATCH_STATE_NODATA, WATCH_STATE_SUSPENDED, WATCH_STATE_CEILOMETER_CONTROLLED ) = ( 'NORMAL', 'ALARM', 'NODATA', 'SUSPENDED', 'CEILOMETER_CONTROLLED' ) WATCH_DATA_KEYS = ( WATCH_DATA_ALARM, WATCH_DATA_METRIC, WATCH_DATA_TIME, WATCH_DATA_NAMESPACE, WATCH_DATA ) = ( 'watch_name', 'metric_name', 'timestamp', 'namespace', 'data' ) VALIDATE_PARAM_KEYS = ( PARAM_TYPE, PARAM_DEFAULT, PARAM_NO_ECHO, PARAM_ALLOWED_VALUES, PARAM_ALLOWED_PATTERN, PARAM_MAX_LENGTH, PARAM_MIN_LENGTH, PARAM_MAX_VALUE, PARAM_MIN_VALUE, PARAM_DESCRIPTION, PARAM_CONSTRAINT_DESCRIPTION, PARAM_LABEL ) = ( 'Type', 'Default', 'NoEcho', 'AllowedValues', 'AllowedPattern', 'MaxLength', 'MinLength', 'MaxValue', 'MinValue', 'Description', 'ConstraintDescription', 'Label' ) VALIDATE_PARAM_TYPES = ( PARAM_TYPE_STRING, PARAM_TYPE_NUMBER, PARAM_TYPE_COMMA_DELIMITED_LIST, PARAM_TYPE_JSON ) = ( 'String', 'Number', 'CommaDelimitedList', 'Json' ) SOFTWARE_CONFIG_KEYS = ( SOFTWARE_CONFIG_ID, SOFTWARE_CONFIG_NAME, SOFTWARE_CONFIG_GROUP, SOFTWARE_CONFIG_CONFIG, SOFTWARE_CONFIG_INPUTS, SOFTWARE_CONFIG_OUTPUTS, SOFTWARE_CONFIG_OPTIONS, ) = ( 'id', 'name', 'group', 'config', 'inputs', 'outputs', 'options', ) SOFTWARE_DEPLOYMENT_KEYS = ( SOFTWARE_DEPLOYMENT_ID, SOFTWARE_DEPLOYMENT_CONFIG_ID, SOFTWARE_DEPLOYMENT_SERVER_ID, SOFTWARE_DEPLOYMENT_INPUT_VALUES, SOFTWARE_DEPLOYMENT_OUTPUT_VALUES, SOFTWARE_DEPLOYMENT_ACTION, SOFTWARE_DEPLOYMENT_STATUS, SOFTWARE_DEPLOYMENT_STATUS_REASON ) = ( 'id', 'config_id', 'server_id', 'input_values', 'output_values', 'action', 'status', 'status_reason' ) heat-2014.1.5/heat/rpc/client.py0000664000567000056700000004507612540642614017402 0ustar jenkinsjenkins00000000000000 # Copyright 2012, Red Hat, Inc. # # 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. """ Client side of the heat engine RPC API. """ from heat.rpc import api import heat.openstack.common.rpc.proxy class EngineClient(heat.openstack.common.rpc.proxy.RpcProxy): '''Client side of the heat engine rpc API. API version history:: 1.0 - Initial version. 1.1 - Add support_status argument to list_resource_types() ''' BASE_RPC_API_VERSION = '1.0' def __init__(self): super(EngineClient, self).__init__( topic=api.ENGINE_TOPIC, default_version=self.BASE_RPC_API_VERSION) def identify_stack(self, ctxt, stack_name): """ The identify_stack method returns the full stack identifier for a single, live stack given the stack name. :param ctxt: RPC context. :param stack_name: Name of the stack you want to see, or None to see all """ return self.call(ctxt, self.make_msg('identify_stack', stack_name=stack_name)) def list_stacks(self, ctxt, limit=None, marker=None, sort_keys=None, sort_dir=None, filters=None, tenant_safe=True): """ The list_stacks method returns attributes of all stacks. It supports pagination (``limit`` and ``marker``), sorting (``sort_keys`` and ``sort_dir``) and filtering (``filters``) of the results. :param ctxt: RPC context. :param limit: the number of stacks to list (integer or string) :param marker: the ID of the last item in the previous page :param sort_keys: an array of fields used to sort the list :param sort_dir: the direction of the sort ('asc' or 'desc') :param filters: a dict with attribute:value to filter the list :param tenant_safe: if true, scope the request by the current tenant :returns: a list of stacks """ return self.call(ctxt, self.make_msg('list_stacks', limit=limit, sort_keys=sort_keys, marker=marker, sort_dir=sort_dir, filters=filters, tenant_safe=tenant_safe)) def count_stacks(self, ctxt, filters=None, tenant_safe=True): """ Return the number of stacks that match the given filters :param ctxt: RPC context. :param filters: a dict of ATTR:VALUE to match against stacks :param tenant_safe: if true, scope the request by the current tenant :returns: a integer representing the number of matched stacks """ return self.call(ctxt, self.make_msg('count_stacks', filters=filters, tenant_safe=tenant_safe)) def show_stack(self, ctxt, stack_identity): """ Return detailed information about one or all stacks. :param ctxt: RPC context. :param stack_identity: Name of the stack you want to show, or None to show all """ return self.call(ctxt, self.make_msg('show_stack', stack_identity=stack_identity)) def preview_stack(self, ctxt, stack_name, template, params, files, args): """ Simulates a new stack using the provided template. Note that at this stage the template has already been fetched from the heat-api process if using a template-url. :param ctxt: RPC context. :param stack_name: Name of the stack you want to create. :param template: Template of stack you want to create. :param params: Stack Input Params/Environment :param files: files referenced from the environment. :param args: Request parameters/args passed from API """ return self.call(ctxt, self.make_msg('preview_stack', stack_name=stack_name, template=template, params=params, files=files, args=args)) def create_stack(self, ctxt, stack_name, template, params, files, args): """ The create_stack method creates a new stack using the template provided. Note that at this stage the template has already been fetched from the heat-api process if using a template-url. :param ctxt: RPC context. :param stack_name: Name of the stack you want to create. :param template: Template of stack you want to create. :param params: Stack Input Params/Environment :param files: files referenced from the environment. :param args: Request parameters/args passed from API """ return self.call(ctxt, self.make_msg('create_stack', stack_name=stack_name, template=template, params=params, files=files, args=args)) def update_stack(self, ctxt, stack_identity, template, params, files, args): """ The update_stack method updates an existing stack based on the provided template and parameters. Note that at this stage the template has already been fetched from the heat-api process if using a template-url. :param ctxt: RPC context. :param stack_name: Name of the stack you want to create. :param template: Template of stack you want to create. :param params: Stack Input Params/Environment :param files: files referenced from the environment. :param args: Request parameters/args passed from API """ return self.call(ctxt, self.make_msg('update_stack', stack_identity=stack_identity, template=template, params=params, files=files, args=args)) def validate_template(self, ctxt, template, params=None): """ The validate_template method uses the stack parser to check the validity of a template. :param ctxt: RPC context. :param template: Template of stack you want to create. :param params: Stack Input Params/Environment """ return self.call(ctxt, self.make_msg('validate_template', template=template, params=params)) def authenticated_to_backend(self, ctxt): """ Verify that the credentials in the RPC context are valid for the current cloud backend. :param ctxt: RPC context. """ return self.call(ctxt, self.make_msg('authenticated_to_backend')) def get_template(self, ctxt, stack_identity): """ Get the template. :param ctxt: RPC context. :param stack_name: Name of the stack you want to see. """ return self.call(ctxt, self.make_msg('get_template', stack_identity=stack_identity)) def delete_stack(self, ctxt, stack_identity, cast=True): """ The delete_stack method deletes a given stack. :param ctxt: RPC context. :param stack_identity: Name of the stack you want to delete. :param cast: cast the message or use call (default: True) """ rpc_method = self.cast if cast else self.call return rpc_method(ctxt, self.make_msg('delete_stack', stack_identity=stack_identity)) def abandon_stack(self, ctxt, stack_identity): """ The abandon_stack method deletes a given stack but resources would not be deleted. :param ctxt: RPC context. :param stack_identity: Name of the stack you want to abandon. """ return self.call(ctxt, self.make_msg('abandon_stack', stack_identity=stack_identity)) def list_resource_types(self, ctxt, support_status=None): """ Get a list of valid resource types. :param ctxt: RPC context. """ return self.call(ctxt, self.make_msg('list_resource_types', support_status=support_status), version='1.1') def resource_schema(self, ctxt, type_name): """ Get the schema for a resource type. :param ctxt: RPC context. """ return self.call(ctxt, self.make_msg('resource_schema', type_name=type_name)) def generate_template(self, ctxt, type_name): """ Generate a template based on the specified type. :param ctxt: RPC context. :param type_name: The resource type name to generate a template for. """ return self.call(ctxt, self.make_msg('generate_template', type_name=type_name)) def list_events(self, ctxt, stack_identity): """ The list_events method lists all events associated with a given stack. :param ctxt: RPC context. :param stack_identity: Name of the stack you want to get events for. """ return self.call(ctxt, self.make_msg('list_events', stack_identity=stack_identity)) def describe_stack_resource(self, ctxt, stack_identity, resource_name): """ Get detailed resource information about a particular resource. :param ctxt: RPC context. :param stack_identity: Name of the stack. :param resource_name: the Resource. """ return self.call(ctxt, self.make_msg('describe_stack_resource', stack_identity=stack_identity, resource_name=resource_name)) def find_physical_resource(self, ctxt, physical_resource_id): """ Return an identifier for the resource with the specified physical resource ID. :param ctxt RPC context. :param physcial_resource_id The physical resource ID to look up. """ return self.call(ctxt, self.make_msg( 'find_physical_resource', physical_resource_id=physical_resource_id)) def describe_stack_resources(self, ctxt, stack_identity, resource_name): """ Get detailed resource information about one or more resources. :param ctxt: RPC context. :param stack_identity: Name of the stack. :param resource_name: the Resource. """ return self.call(ctxt, self.make_msg('describe_stack_resources', stack_identity=stack_identity, resource_name=resource_name)) def list_stack_resources(self, ctxt, stack_identity): """ List the resources belonging to a stack. :param ctxt: RPC context. :param stack_identity: Name of the stack. """ return self.call(ctxt, self.make_msg('list_stack_resources', stack_identity=stack_identity)) def stack_suspend(self, ctxt, stack_identity): return self.call(ctxt, self.make_msg('stack_suspend', stack_identity=stack_identity)) def stack_resume(self, ctxt, stack_identity): return self.call(ctxt, self.make_msg('stack_resume', stack_identity=stack_identity)) def metadata_update(self, ctxt, stack_identity, resource_name, metadata): """ Update the metadata for the given resource. """ return self.call(ctxt, self.make_msg('metadata_update', stack_identity=stack_identity, resource_name=resource_name, metadata=metadata)) def resource_signal(self, ctxt, stack_identity, resource_name, details): """ Generate an alarm on the resource. :param ctxt: RPC context. :param stack_identity: Name of the stack. :param resource_name: the Resource. :param details: the details of the signal. """ return self.call(ctxt, self.make_msg('resource_signal', stack_identity=stack_identity, resource_name=resource_name, details=details)) def create_watch_data(self, ctxt, watch_name, stats_data): ''' This could be used by CloudWatch and WaitConditions and treat HA service events like any other CloudWatch. :param ctxt: RPC context. :param watch_name: Name of the watch/alarm :param stats_data: The data to post. ''' return self.call(ctxt, self.make_msg('create_watch_data', watch_name=watch_name, stats_data=stats_data)) def show_watch(self, ctxt, watch_name): """ The show_watch method returns the attributes of one watch or all watches if no watch_name is passed :param ctxt: RPC context. :param watch_name: Name of the watch/alarm you want to see, or None to see all """ return self.call(ctxt, self.make_msg('show_watch', watch_name=watch_name)) def show_watch_metric(self, ctxt, metric_namespace=None, metric_name=None): """ The show_watch_metric method returns the datapoints associated with a specified metric, or all metrics if no metric_name is passed :param ctxt: RPC context. :param metric_namespace: Name of the namespace you want to see, or None to see all :param metric_name: Name of the metric you want to see, or None to see all """ return self.call(ctxt, self.make_msg('show_watch_metric', metric_namespace=metric_namespace, metric_name=metric_name)) def set_watch_state(self, ctxt, watch_name, state): ''' Temporarily set the state of a given watch :param ctxt: RPC context. :param watch_name: Name of the watch :param state: State (must be one defined in WatchRule class) ''' return self.call(ctxt, self.make_msg('set_watch_state', watch_name=watch_name, state=state)) def get_revision(self, ctxt): return self.call(ctxt, self.make_msg('get_revision')) def show_software_config(self, cnxt, config_id): return self.call(cnxt, self.make_msg('show_software_config', config_id=config_id)) def create_software_config(self, cnxt, group, name, config, inputs=[], outputs=[], options={}): return self.call(cnxt, self.make_msg('create_software_config', group=group, name=name, config=config, inputs=inputs, outputs=outputs, options=options)) def delete_software_config(self, cnxt, config_id): return self.call(cnxt, self.make_msg('delete_software_config', config_id=config_id)) def list_software_deployments(self, cnxt, server_id=None): return self.call(cnxt, self.make_msg('list_software_deployments', server_id=server_id)) def metadata_software_deployments(self, cnxt, server_id): return self.call(cnxt, self.make_msg('metadata_software_deployments', server_id=server_id)) def show_software_deployment(self, cnxt, deployment_id): return self.call(cnxt, self.make_msg('show_software_deployment', deployment_id=deployment_id)) def create_software_deployment(self, cnxt, server_id, config_id=None, input_values={}, action='INIT', status='COMPLETE', status_reason='', stack_user_project_id=None): return self.call(cnxt, self.make_msg( 'create_software_deployment', server_id=server_id, config_id=config_id, input_values=input_values, action=action, status=status, status_reason=status_reason, stack_user_project_id=stack_user_project_id)) def update_software_deployment(self, cnxt, deployment_id, config_id=None, input_values=None, output_values=None, action=None, status=None, status_reason=None): return self.call(cnxt, self.make_msg('update_software_deployment', deployment_id=deployment_id, config_id=config_id, input_values=input_values, output_values=output_values, action=action, status=status, status_reason=status_reason)) def delete_software_deployment(self, cnxt, deployment_id): return self.call(cnxt, self.make_msg('delete_software_deployment', deployment_id=deployment_id)) heat-2014.1.5/heat/version.py0000664000567000056700000000120412540642614017006 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. import pbr.version version_info = pbr.version.VersionInfo('heat') heat-2014.1.5/heat/locale/0000775000567000056700000000000012540643116016207 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/nb/0000775000567000056700000000000012540643116016606 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/nb/LC_MESSAGES/0000775000567000056700000000000012540643116020373 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/nb/LC_MESSAGES/heat.po0000664000567000056700000050046712540642614021672 0ustar jenkinsjenkins00000000000000# Norwegian Bokmål translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Norwegian Bokmål " "(http://www.transifex.com/projects/p/openstack/language/nb/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "En ukjent feil oppsto." #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "Resultat var %s" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "%r feilet. Prøver på nytt." #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/hu/0000775000567000056700000000000012540643116016623 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/hu/LC_MESSAGES/0000775000567000056700000000000012540643116020410 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/hu/LC_MESSAGES/heat.po0000664000567000056700000050034612540642614021703 0ustar jenkinsjenkins00000000000000# Hungarian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Hungarian " "(http://www.transifex.com/projects/p/openstack/language/hu/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/eu/0000775000567000056700000000000012540643116016620 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/eu/LC_MESSAGES/0000775000567000056700000000000012540643116020405 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/eu/LC_MESSAGES/heat.po0000664000567000056700000050032712540642614021677 0ustar jenkinsjenkins00000000000000# Basque translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-11-06 03:20+0000\n" "Last-Translator: Tom Fifield \n" "Language-Team: Basque " "(http://www.transifex.com/projects/p/openstack/language/eu/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/fil/0000775000567000056700000000000012540643116016761 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fil/LC_MESSAGES/0000775000567000056700000000000012540643116020546 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fil/LC_MESSAGES/heat.po0000664000567000056700000050034412540642614022037 0ustar jenkinsjenkins00000000000000# Filipino translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Filipino " "(http://www.transifex.com/projects/p/openstack/language/fil/)\n" "Plural-Forms: nplurals=2; plural=(n > 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ka_GE/0000775000567000056700000000000012540643116017155 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ka_GE/LC_MESSAGES/0000775000567000056700000000000012540643116020742 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ka_GE/LC_MESSAGES/heat.po0000664000567000056700000050036412540642614022235 0ustar jenkinsjenkins00000000000000# Georgian (Georgia) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Georgian (Georgia) " "(http://www.transifex.com/projects/p/openstack/language/ka_GE/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/pt/0000775000567000056700000000000012540643116016632 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pt/LC_MESSAGES/0000775000567000056700000000000012540643116020417 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pt/LC_MESSAGES/heat.po0000664000567000056700000050041312540642614021705 0ustar jenkinsjenkins00000000000000# Portuguese translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Portuguese " "(http://www.transifex.com/projects/p/openstack/language/pt/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "Ocorreu uma exceção desconhecida." #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/fr/0000775000567000056700000000000012540643116016616 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fr/LC_MESSAGES/0000775000567000056700000000000012540643116020403 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fr/LC_MESSAGES/heat.po0000664000567000056700000050031412540642614021671 0ustar jenkinsjenkins00000000000000# French translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: fr \n" "Plural-Forms: nplurals=2; plural=(n > 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/hi/0000775000567000056700000000000012540643116016607 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/hi/LC_MESSAGES/0000775000567000056700000000000012540643116020374 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/hi/LC_MESSAGES/heat.po0000664000567000056700000050033612540642614021666 0ustar jenkinsjenkins00000000000000# Hindi translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Hindi " "(http://www.transifex.com/projects/p/openstack/language/hi/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/is_IS/0000775000567000056700000000000012540643116017215 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/is_IS/LC_MESSAGES/0000775000567000056700000000000012540643116021002 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/is_IS/LC_MESSAGES/heat.po0000664000567000056700000050037512540642614022277 0ustar jenkinsjenkins00000000000000# Icelandic (Iceland) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-12-16 02:54+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Icelandic (Iceland) " "(http://www.transifex.com/projects/p/openstack/language/is_IS/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/en_GB/0000775000567000056700000000000012540643116017161 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/en_GB/LC_MESSAGES/0000775000567000056700000000000012540643116020746 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/en_GB/LC_MESSAGES/heat.po0000664000567000056700000050034212540642614022235 0ustar jenkinsjenkins00000000000000# English (United Kingdom) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: en_GB \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/gl/0000775000567000056700000000000012540643116016611 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/gl/LC_MESSAGES/0000775000567000056700000000000012540643116020376 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/gl/LC_MESSAGES/heat.po0000664000567000056700000050034412540642614021667 0ustar jenkinsjenkins00000000000000# Galician translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-29 15:55+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Galician " "(http://www.transifex.com/projects/p/openstack/language/gl/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/tl/0000775000567000056700000000000012540643116016626 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tl/LC_MESSAGES/0000775000567000056700000000000012540643116020413 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tl/LC_MESSAGES/heat.po0000664000567000056700000050034112540642614021701 0ustar jenkinsjenkins00000000000000# Filipino (Philippines) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: fil_PH \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ar/0000775000567000056700000000000012540643116016611 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ar/LC_MESSAGES/0000775000567000056700000000000012540643116020376 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ar/LC_MESSAGES/heat.po0000664000567000056700000050046612540642614021674 0ustar jenkinsjenkins00000000000000# Arabic translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Arabic " "(http://www.transifex.com/projects/p/openstack/language/ar/)\n" "Plural-Forms: nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : " "n%100>=3 && n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ml_IN/0000775000567000056700000000000012540643116017205 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ml_IN/LC_MESSAGES/0000775000567000056700000000000012540643116020772 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ml_IN/LC_MESSAGES/heat.po0000664000567000056700000050037112540642614022263 0ustar jenkinsjenkins00000000000000# Malayalam (India) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-11-27 12:03+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Malayalam (India) " "(http://www.transifex.com/projects/p/openstack/language/ml_IN/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ur/0000775000567000056700000000000012540643116016635 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ur/LC_MESSAGES/0000775000567000056700000000000012540643116020422 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ur/LC_MESSAGES/heat.po0000664000567000056700000050115412540642614021713 0ustar jenkinsjenkins00000000000000# Urdu translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: # Bagban Afzal , 2013 msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 09:16+0000\n" "Last-Translator: Bagban Afzal \n" "Language-Team: Urdu " "(http://www.transifex.com/projects/p/openstack/language/ur/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "غیر درست ,غلط سانچہ Template یو آر ایل" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "نہیں ملا نہیں اسٹیک" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "وضاحت کی کوئی کارروائی نہیں کی" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "ایک سے زیادہ مخصوص اعمال" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "بیان کردہ کوئی اسٹیک نام نہیں" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "بیان کردہ کوئی ٹیمپلیٹ سانچہ نہیں" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "باطل اسٹیک ایڈریس نام و نشان" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/tl_PH/0000775000567000056700000000000012540643116017215 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tl_PH/LC_MESSAGES/0000775000567000056700000000000012540643116021002 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tl_PH/LC_MESSAGES/heat.po0000664000567000056700000050040112540642614022265 0ustar jenkinsjenkins00000000000000# Filipino (Philippines) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Tagalog (Philippines) " "(http://www.transifex.com/projects/p/openstack/language/tl_PH/)\n" "Plural-Forms: nplurals=2; plural=(n > 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/bs/0000775000567000056700000000000012540643116016613 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/bs/LC_MESSAGES/0000775000567000056700000000000012540643116020400 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/bs/LC_MESSAGES/heat.po0000664000567000056700000050031612540642614021670 0ustar jenkinsjenkins00000000000000# Bosnian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: bs \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/kn/0000775000567000056700000000000012540643116016617 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/kn/LC_MESSAGES/0000775000567000056700000000000012540643116020404 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/kn/LC_MESSAGES/heat.po0000664000567000056700000050033312540642614021673 0ustar jenkinsjenkins00000000000000# Kannada translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Kannada " "(http://www.transifex.com/projects/p/openstack/language/kn/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/zh_CN/0000775000567000056700000000000012540643116017210 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/zh_CN/LC_MESSAGES/0000775000567000056700000000000012540643116020775 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/zh_CN/LC_MESSAGES/heat.po0000664000567000056700000050035212540642614022265 0ustar jenkinsjenkins00000000000000# Chinese (Simplified, China) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: zh_Hans_CN \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/he_IL/0000775000567000056700000000000012540643116017167 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/he_IL/LC_MESSAGES/0000775000567000056700000000000012540643116020754 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/he_IL/LC_MESSAGES/heat.po0000664000567000056700000050036512540642614022250 0ustar jenkinsjenkins00000000000000# Hebrew (Israel) translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-01-31 01:55+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Hebrew (Israel) " "(http://www.transifex.com/projects/p/openstack/language/he_IL/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/fi_FI/0000775000567000056700000000000012540643116017163 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fi_FI/LC_MESSAGES/0000775000567000056700000000000012540643116020750 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fi_FI/LC_MESSAGES/heat.po0000664000567000056700000050037112540642614022241 0ustar jenkinsjenkins00000000000000# Finnish (Finland) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Finnish (Finland) " "(http://www.transifex.com/projects/p/openstack/language/fi_FI/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/tr_TR/0000775000567000056700000000000012540643116017241 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tr_TR/LC_MESSAGES/0000775000567000056700000000000012540643116021026 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tr_TR/LC_MESSAGES/heat.po0000664000567000056700000050220312540642614022313 0ustar jenkinsjenkins00000000000000# Turkish (Turkey) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Turkish (Turkey) " "(http://www.transifex.com/projects/p/openstack/language/tr_TR/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "Bilinmeyen bir istisna oluştu." #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "syslog servisi bunlardan biri olmak zorundadır: %s" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "utils.execute için bilinmeyen anahtar kelime argümanları: %r" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "Çalışan komut(alt süreç): %s" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "Sonuç %s" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "%r hatalı. Yeniden deneniyor." #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "Çalışan komut(SSH): %s" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "SSH üzerinde ortam desteklenmemektedir." #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "SSH üzerinde process_input desteklenmemektedir." #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "%s yakalandı, çıkılıyor" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "Yakalanmamış istisna" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "cert_file bulunamadı: %s" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "ca_file bulunamadı: %s" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "key_file bulunamadı: %s" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "Geçersiz SSL sürümü: %s" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "Sürüm tam sayı olmak zorunda" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "Veritabanı istisnası yakalandı." #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "alınan %s" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "%s mesajı için yöntem bulunamadı" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "%s mesajı için yöntem bulunamadı." #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "Geçersi RPC bağlantısı kullanımı." #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "Mesaj işleme başarısız ... atlanıyor." #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "Mesaj işleme başarısız ... yeniden kuyruğa alınacak." #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "AMQP kuyrukları tekrar kuruluyor" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "Cevap gönderiliyor" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "RPC Mesajı Geçersiz." #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "%(msg)s" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "%s servisi için tüketici bağlantısı oluşturuluyor." #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/bg_BG/0000775000567000056700000000000012540643116017147 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/bg_BG/LC_MESSAGES/0000775000567000056700000000000012540643116020734 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/bg_BG/LC_MESSAGES/heat.po0000664000567000056700000050037712540642614022233 0ustar jenkinsjenkins00000000000000# Bulgarian (Bulgaria) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Bulgarian (Bulgaria) " "(http://www.transifex.com/projects/p/openstack/language/bg_BG/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/sl_SI/0000775000567000056700000000000012540643116017220 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sl_SI/LC_MESSAGES/0000775000567000056700000000000012540643116021005 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sl_SI/LC_MESSAGES/heat.po0000664000567000056700000050046612540642614022303 0ustar jenkinsjenkins00000000000000# Slovenian (Slovenia) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Slovenian (Slovenia) " "(http://www.transifex.com/projects/p/openstack/language/sl_SI/)\n" "Plural-Forms: nplurals=4; plural=(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 " "|| n%100==4 ? 2 : 3)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ru_RU/0000775000567000056700000000000012540643116017243 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ru_RU/LC_MESSAGES/0000775000567000056700000000000012540643116021030 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ru_RU/LC_MESSAGES/heat.po0000664000567000056700000050050412540642614022317 0ustar jenkinsjenkins00000000000000# Russian (Russia) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Russian (Russia) " "(http://www.transifex.com/projects/p/openstack/language/ru_RU/)\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && " "n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/hr/0000775000567000056700000000000012540643116016620 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/hr/LC_MESSAGES/0000775000567000056700000000000012540643116020405 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/hr/LC_MESSAGES/heat.po0000664000567000056700000050045712540642614021703 0ustar jenkinsjenkins00000000000000# Croatian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Croatian " "(http://www.transifex.com/projects/p/openstack/language/hr/)\n" "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && " "n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/vi_VN/0000775000567000056700000000000012540643116017230 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/vi_VN/LC_MESSAGES/0000775000567000056700000000000012540643116021015 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/vi_VN/LC_MESSAGES/heat.po0000664000567000056700000050101412540642614022301 0ustar jenkinsjenkins00000000000000# Vietnamese (Vietnam) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Vietnamese (Viet Nam) " "(http://www.transifex.com/projects/p/openstack/language/vi_VN/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "Xảy ra lỗi chưa xác định thuộc về hệ thống ." #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "Lỗi exception trong tiến trình định dạng chuỗi" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" "Thông số không hợp lệ: Unicode hiện chưa được hỗ trợ bởi hệ cơ sở dữ liệu" " hiện tại." #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "Lỗi exception DB khi bao bọc." #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/en_AU/0000775000567000056700000000000012540643116017176 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/en_AU/LC_MESSAGES/0000775000567000056700000000000012540643116020763 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/en_AU/LC_MESSAGES/heat.po0000664000567000056700000050033512540642614022254 0ustar jenkinsjenkins00000000000000# English (Australia) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: en_AU \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/pt_BR/0000775000567000056700000000000012540643116017215 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pt_BR/LC_MESSAGES/0000775000567000056700000000000012540643116021002 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pt_BR/LC_MESSAGES/heat.po0000664000567000056700000050033412540642614022272 0ustar jenkinsjenkins00000000000000# Portuguese (Brazil) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: pt_BR \n" "Plural-Forms: nplurals=2; plural=(n > 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ca/0000775000567000056700000000000012540643116016572 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ca/LC_MESSAGES/0000775000567000056700000000000012540643116020357 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ca/LC_MESSAGES/heat.po0000664000567000056700000050034212540642614021646 0ustar jenkinsjenkins00000000000000# Catalan translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Catalan " "(http://www.transifex.com/projects/p/openstack/language/ca/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/it_IT/0000775000567000056700000000000012540643116017217 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/it_IT/LC_MESSAGES/0000775000567000056700000000000012540643116021004 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/it_IT/LC_MESSAGES/heat.po0000664000567000056700000050036512540642614022300 0ustar jenkinsjenkins00000000000000# Italian (Italy) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Italian (Italy) " "(http://www.transifex.com/projects/p/openstack/language/it_IT/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/mr_IN/0000775000567000056700000000000012540643116017213 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/mr_IN/LC_MESSAGES/0000775000567000056700000000000012540643116021000 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/mr_IN/LC_MESSAGES/heat.po0000664000567000056700000050035412540642614022272 0ustar jenkinsjenkins00000000000000# Marathi (India) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-16 22:17+0000\n" "Last-Translator: Tom Fifield \n" "Language-Team: Marathi (India) " "(http://www.transifex.com/projects/p/openstack/language/mr_IN/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/he/0000775000567000056700000000000012540643116016603 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/he/LC_MESSAGES/0000775000567000056700000000000012540643116020370 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/he/LC_MESSAGES/heat.po0000664000567000056700000050034012540642614021655 0ustar jenkinsjenkins00000000000000# Hebrew translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-01-31 01:55+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Hebrew " "(http://www.transifex.com/projects/p/openstack/language/he/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/te_IN/0000775000567000056700000000000012540643116017205 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/te_IN/LC_MESSAGES/0000775000567000056700000000000012540643116020772 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/te_IN/LC_MESSAGES/heat.po0000664000567000056700000050036312540642614022264 0ustar jenkinsjenkins00000000000000# Telugu (India) translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-03-27 23:49+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Telugu (India) " "(http://www.transifex.com/projects/p/openstack/language/te_IN/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/sr/0000775000567000056700000000000012540643116016633 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sr/LC_MESSAGES/0000775000567000056700000000000012540643116020420 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sr/LC_MESSAGES/heat.po0000664000567000056700000050054212540642614021711 0ustar jenkinsjenkins00000000000000# Serbian translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-03-27 23:49+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Serbian " "(http://www.transifex.com/projects/p/openstack/language/sr/)\n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && " "n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "Ime stack-a" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "syslog okruženje mora biti jedno od: %s" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/heat.pot0000664000567000056700000050027612540642614017670 0ustar jenkinsjenkins00000000000000# Translations template for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2014. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat jenkins.heat.propose.translation.update.189\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/sv/0000775000567000056700000000000012540643116016637 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sv/LC_MESSAGES/0000775000567000056700000000000012540643116020424 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sv/LC_MESSAGES/heat.po0000664000567000056700000050034212540642614021713 0ustar jenkinsjenkins00000000000000# Swedish translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-11-27 12:03+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Swedish " "(http://www.transifex.com/projects/p/openstack/language/sv/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ms/0000775000567000056700000000000012540643116016626 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ms/LC_MESSAGES/0000775000567000056700000000000012540643116020413 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ms/LC_MESSAGES/heat.po0000664000567000056700000050032712540642614021705 0ustar jenkinsjenkins00000000000000# Malay translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Malay " "(http://www.transifex.com/projects/p/openstack/language/ms/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/pl_PL/0000775000567000056700000000000012540643116017215 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pl_PL/LC_MESSAGES/0000775000567000056700000000000012540643116021002 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pl_PL/LC_MESSAGES/heat.po0000664000567000056700000050070312540642614022272 0ustar jenkinsjenkins00000000000000# Polish (Poland) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Polish (Poland) " "(http://www.transifex.com/projects/p/openstack/language/pl_PL/)\n" "Plural-Forms: nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && " "(n%100<10 || n%100>=20) ? 1 : 2)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "Wynik był %s" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "Nie można otworzyć gniazda." #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "Subskrybowanie do %s" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "Nie można wysłać do tego gniazda." #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "%(msg)s" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "Wysyłanie wiadomości do: %s" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/zh_TW/0000775000567000056700000000000012540643116017242 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/zh_TW/LC_MESSAGES/0000775000567000056700000000000012540643116021027 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/zh_TW/LC_MESSAGES/heat.po0000664000567000056700000050035412540642614022321 0ustar jenkinsjenkins00000000000000# Chinese (Traditional, Taiwan) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: zh_Hant_TW \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/cs/0000775000567000056700000000000012540643116016614 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/cs/LC_MESSAGES/0000775000567000056700000000000012540643116020401 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/cs/LC_MESSAGES/heat.po0000664000567000056700000050043112540642614021667 0ustar jenkinsjenkins00000000000000# Czech translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: cs \n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && " "n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ta/0000775000567000056700000000000012540643116016613 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ta/LC_MESSAGES/0000775000567000056700000000000012540643116020400 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ta/LC_MESSAGES/heat.po0000664000567000056700000050033612540642614021672 0ustar jenkinsjenkins00000000000000# Tamil translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-03-27 23:49+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Tamil " "(http://www.transifex.com/projects/p/openstack/language/ta/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ro/0000775000567000056700000000000012540643116016627 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ro/LC_MESSAGES/0000775000567000056700000000000012540643116020414 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ro/LC_MESSAGES/heat.po0000664000567000056700000050042012540642614021700 0ustar jenkinsjenkins00000000000000# Romanian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Romanian " "(http://www.transifex.com/projects/p/openstack/language/ro/)\n" "Plural-Forms: nplurals=3; " "plural=(n==1?0:(((n%100>19)||((n%100==0)&&(n!=0)))?2:1))\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/it/0000775000567000056700000000000012540643116016623 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/it/LC_MESSAGES/0000775000567000056700000000000012540643116020410 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/it/LC_MESSAGES/heat.po0000664000567000056700000050031612540642614021700 0ustar jenkinsjenkins00000000000000# Italian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: it \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ko/0000775000567000056700000000000012540643116016620 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ko/LC_MESSAGES/0000775000567000056700000000000012540643116020405 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ko/LC_MESSAGES/heat.po0000664000567000056700000050030612540642614021674 0ustar jenkinsjenkins00000000000000# Korean translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: ko \n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/tr/0000775000567000056700000000000012540643116016634 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tr/LC_MESSAGES/0000775000567000056700000000000012540643116020421 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/tr/LC_MESSAGES/heat.po0000664000567000056700000050030712540642614021711 0ustar jenkinsjenkins00000000000000# Turkish translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: tr \n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/de/0000775000567000056700000000000012540643116016577 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/de/LC_MESSAGES/0000775000567000056700000000000012540643116020364 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/de/LC_MESSAGES/heat.po0000664000567000056700000050031512540642614021653 0ustar jenkinsjenkins00000000000000# German translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: de \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/da/0000775000567000056700000000000012540643116016573 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/da/LC_MESSAGES/0000775000567000056700000000000012540643116020360 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/da/LC_MESSAGES/heat.po0000664000567000056700000050031512540642614021647 0ustar jenkinsjenkins00000000000000# Danish translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: da \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/sq/0000775000567000056700000000000012540643116016632 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sq/LC_MESSAGES/0000775000567000056700000000000012540643116020417 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sq/LC_MESSAGES/heat.po0000664000567000056700000050034412540642614021710 0ustar jenkinsjenkins00000000000000# Albanian translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-03-27 23:49+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Albanian " "(http://www.transifex.com/projects/p/openstack/language/sq/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/fa/0000775000567000056700000000000012540643116016575 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fa/LC_MESSAGES/0000775000567000056700000000000012540643116020362 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/fa/LC_MESSAGES/heat.po0000664000567000056700000050033312540642614021651 0ustar jenkinsjenkins00000000000000# Persian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-11-27 12:03+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Persian " "(http://www.transifex.com/projects/p/openstack/language/fa/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/zh_HK/0000775000567000056700000000000012540643116017212 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/zh_HK/LC_MESSAGES/0000775000567000056700000000000012540643116020777 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/zh_HK/LC_MESSAGES/heat.po0000664000567000056700000050041512540642614022267 0ustar jenkinsjenkins00000000000000# Chinese (Traditional, Hong Kong SAR China) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Chinese (Hong Kong) " "(http://www.transifex.com/projects/p/openstack/language/zh_HK/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/sk/0000775000567000056700000000000012540643116016624 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sk/LC_MESSAGES/0000775000567000056700000000000012540643116020411 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sk/LC_MESSAGES/heat.po0000664000567000056700000050037312540642614021704 0ustar jenkinsjenkins00000000000000# Slovak translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Slovak " "(http://www.transifex.com/projects/p/openstack/language/sk/)\n" "Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/sw_KE/0000775000567000056700000000000012540643116017217 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sw_KE/LC_MESSAGES/0000775000567000056700000000000012540643116021004 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/sw_KE/LC_MESSAGES/heat.po0000664000567000056700000050036512540642614022300 0ustar jenkinsjenkins00000000000000# Swahili (Kenya) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Swahili (Kenya) " "(http://www.transifex.com/projects/p/openstack/language/sw_KE/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/km/0000775000567000056700000000000012540643116016616 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/km/LC_MESSAGES/0000775000567000056700000000000012540643116020403 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/km/LC_MESSAGES/heat.po0000664000567000056700000050032712540642614021675 0ustar jenkinsjenkins00000000000000# Khmer translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-11-27 12:03+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Khmer " "(http://www.transifex.com/projects/p/openstack/language/km/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ne/0000775000567000056700000000000012540643116016611 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ne/LC_MESSAGES/0000775000567000056700000000000012540643116020376 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ne/LC_MESSAGES/heat.po0000664000567000056700000050034012540642614021663 0ustar jenkinsjenkins00000000000000# Nepali translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Nepali " "(http://www.transifex.com/projects/p/openstack/language/ne/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ja/0000775000567000056700000000000012540643116016601 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ja/LC_MESSAGES/0000775000567000056700000000000012540643116020366 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ja/LC_MESSAGES/heat.po0000664000567000056700000050031012540642614021650 0ustar jenkinsjenkins00000000000000# Japanese translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: ja \n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/en_US/0000775000567000056700000000000012540643116017220 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/en_US/LC_MESSAGES/0000775000567000056700000000000012540643116021005 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/en_US/LC_MESSAGES/heat.po0000664000567000056700000050034112540642614022273 0ustar jenkinsjenkins00000000000000# English (United States) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: en_US \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/eu_ES/0000775000567000056700000000000012540643116017207 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/eu_ES/LC_MESSAGES/0000775000567000056700000000000012540643116020774 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/eu_ES/LC_MESSAGES/heat.po0000664000567000056700000050036312540642614022266 0ustar jenkinsjenkins00000000000000# Basque (Spain) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-11-27 12:03+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Basque (Spain) " "(http://www.transifex.com/projects/p/openstack/language/eu_ES/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/id/0000775000567000056700000000000012540643116016603 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/id/LC_MESSAGES/0000775000567000056700000000000012540643116020370 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/id/LC_MESSAGES/heat.po0000664000567000056700000050034112540642614021656 0ustar jenkinsjenkins00000000000000# Indonesian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Indonesian " "(http://www.transifex.com/projects/p/openstack/language/id/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ko_KR/0000775000567000056700000000000012540643116017214 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ko_KR/LC_MESSAGES/0000775000567000056700000000000012540643116021001 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ko_KR/LC_MESSAGES/heat.po0000664000567000056700000051543012540642614022274 0ustar jenkinsjenkins00000000000000# Korean (South Korea) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Korean (Korea) " "(http://www.transifex.com/projects/p/openstack/language/ko_KR/)\n" "Plural-Forms: nplurals=1; plural=0\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "알 수 없는 예외가 발생했습니다. " #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "문자열 형식화 오퍼레이션의 예외" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "SSL 모드로 서버를 실행하는 경우 구성 파일에서 cert_file 및 key_file 옵션 값 둘 다를 지정해야 합니다. " #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "SIGTERM 수신" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "%d 작업자 시작 중" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "자원 처리 예외: %s" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "%(code)s을(를) 사용자에게 리턴 중: %(explanation)s" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "기존 예외가 삭제됨: %s" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "캐시된 파일 %s 다시 로드 중" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "획득한 `%s` 잠금을 해제할 수 없음" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "더 이상 사용되지 않음: %s" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "%(log_config)s 설정 기록을 불러오는 중 오류가 발생했습니다: %(err_msg)s" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "syslog 기능이 다음 중 하나여야 함: %s" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "더 이상 사용되지 않는 구성에 대한 심각한 호출: %(msg)s" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "태스크 실행이 %s초의 간격을 지속함" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "고정 기간 루프 호출에서" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "%.02f 초 동안 대기할 동적 순환 반복 호출" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "동적 루프 호출에서" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "%s 유형의 일치에 대한 핸들러가 없음" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "utils.execute에 대해 알 수 없는 키워드 인수를 가져옴: %r" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "cmd(하위 프로세스) 실행 중: %s" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "결과는 %s입니다." #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "%r 실패. 재시도 중입니다. " #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "cmd(SSH) 실행 중: %s" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "환경이 SSH를 통해 지원되지 않음" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "process_input이 SSH를 통해 지원되지 않음" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "CONF의 전체 세트:" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "%s 발견, 종료 중" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "상위 프로세스가 예기치 않게 정지했습니다. 종료 중" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "처리되지 않은 예외" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "포크가 너무 빠름. 정지 중" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "%d 하위를 시작했음" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "%(pid)d 하위가 %(sig)d 신호에 의해 강제 종료됨" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "%(pid)s 하위가 %(code)d 상태와 함께 종료했음" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "pid %d이(가) 하위 목록에 없음" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "%s 발견, 하위 중지 중" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "%d 하위에서 종료하기를 대기 중임" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "cert_file을 찾을 수 없음: %s" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "ca_file을 찾을 수 없음: %s" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "key_file을 찾을 수 없음: %s" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "잘못된 SSL 버전 : %s" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "올바르지 않은 매개변수: Unicode는 현재 데이터베이스에서 지원되지 않습니다. " #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "버전은 정수여야 함" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "DB 예외가 랩핑되었습니다." #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "SQL 연결에 실패했습니다. %s번의 시도가 남았습니다. " #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "제공되는 정렬 키가 올바르지 않습니다. " #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "ID가 sort_keys에 없습니다. sort_keys가 고유합니까?" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "알 수 없는 정렬 방향입니다. 'desc' 또는 'asc'여야 함" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" "col_name_col_instance 매개변수에 %s 열을 지정하십시오. sqlite에서 지원하지 않는 유형이 열에 있으므로 이는" " 필수입니다." #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" "%s 열에 올바르지 않은 열 인스턴스 유형이 col_name_col_instance 매개변수에 있습니다. " "sqlalchemy.Column의 인스턴스여야 합니다." #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "%s이(가) 유효한 우선순위에 없음" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "알림 시스템에 보내려고 시도하는 중 '%(e)s' 문제점이 발생했습니다. 페이로드=%(payload)s" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "%s 알리미를 로드하지 못했습니다. 이들 알림은 발송되지 않습니다. " #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "문제점 '%(e)s' 가 알림 드라이버 %(driver)s에 전송을 시도합니다." #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "rabbit_notifier는 이제 사용되지 않습니다. 대신 rpc_notifier를 사용하십시오. " #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "%(topic)s(으)로 알림을 발송할 수 없습니다. 페이로드=%(message)s" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "풀이 새 연결을 작성 중임" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "_call_waiters: %s" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "압축이 풀리지 않은 컨텍스트: %s" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "UNIQUE_ID는 %s입니다." #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "%s 수신" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "메시지에 대한 메소드가 없음: %s" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "메시지에 대한 메소드가 없음: %s" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "메시지 처리 중에 예상된 예외(%s)" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "메시지 처리 중 예외" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "%s에서 동기 호출 작성 중..." #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "MSG_ID는 %s입니다. " #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "%s에서 비동기 캐스트 작성 중..." #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "비동기 팬아웃 캐스트 작성 중..." #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "%(topic)s에서 %(event_type)s 보내는 중" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "알 수 없는 RPC 관련 예외가 발생했습니다. " #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" "원격 오류: %(exc_type)s %(value)s\n" "%(traceback)s." #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" "RPC 응답 대기 시간을 초과 했습니다 - 토픽: \"%(topic)s\", RPC 방식: \"%(method)s\" 정보: " "\"%(info)s\"" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "중복 메시지(%(msg_id)s)를 찾았습니다. 이를 건너뜁니다. " #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "RPC 연결의 올바르지 않은 재사용입니다. " #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "지정된 RPC 버전 %(version)s이(가) 이 엔드포인트에서 지원되지 않습니다. " #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "지정된 RPC 엔벨로프 버전 %(version)s이(가) 이 엔드포인트에서 지원되지 않습니다. " #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "%s 예외를 호출자에게 리턴 중" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "%(hostname)s:%(port)d에서 AMQP 서버에 다시 연결 중" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "%(hostname)s:%(port)d에서 AMQP 서버에 연결되었음" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" "%(max_retries)d번 시도 후에 %(hostname)s:%(port)d에서 AMQP 서버를 연결할 수 없음: " "%(err_str)s" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" "%(hostname)s:%(port)d의 AMQP 서버에 접근할 수 없음: %(err_str)s. %(sleep_time)d초 내에" " 다시 시도하십시오. " #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "'%(topic)s' 주제에 대한 이용자를 선언하지 못했음: %(err_str)s" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "RPC 응답 대기 중에 제한시간 초과: %s" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "큐의 메시지를 이용하지 못했음: %s" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "'%(topic)s' 주제에 메시지를 공개하지 못했음: %(err_str)s" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "메시지를 처리하지 못했습니다. 건너뛰는 중입니다. " #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "AMQP 서버 %(e)s에 연결할 수 없습니다. %(delay)s 초 휴면 상태입니다. " #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "%s의 AMQP 서버에 연결했음" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "AMQP 큐 재설정" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "메시지 처리 오류입니다. 건너뛰는 중입니다. " #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "JSON 직렬화에 실패했습니다. " #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "직렬화 취소 중: %s" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "%(type)s을(를) 갖는 %(addr)s에 연결 중" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "-> %(subscribe)s에 등록" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "-> 바인드: %(bind)s" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "소켓을 열 수 없습니다. " #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "%s에 등록" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "이 소켓에서 수신할 수 없습니다. " #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "이 소켓에서 전송할 수 없습니다. " #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "다음 컨텍스트를 갖고 기능 실행 중: %s" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "응답 보내는 중" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "RPC 메시지에 메소드가 없습니다. " #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "리액터 등록 중" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "인 리액터 등록" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "소켓 이용 중" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "주제에 대한 프록시 작성: %s" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "올바르지 않은 문자가 있는 주제. " #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "주제 소켓 파일 작성에 실패했습니다. " #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "%(topic)s 주제에 대한 로컬 주제별 백로그 버퍼가 가득 찼습니다. 메시지 삭제 중입니다. " #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "ZeroMQ 수신기 디먼을 작성할 수 없습니다. 소켓이 이미 사용 중일 수 있습니다. " #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "CONSUMER RECEIVED DATA: %s" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "ZMQ Envelope 버전을 지원하지 않거나 알 수 없습니다. " #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "주제 등록을 건너뜁니다. 이미 등록되었습니다. " #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "이용자: zmq.%s" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "페이로드 작성 중" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "응답 대기자를 위한 큐 소켓 작성 중" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "캐스트 보내는 중" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "캐스트 전송. 응답 대기 중" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "수신된 메시지: %s" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "응답 압축 해제 중" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "지원되지 않거나 알 수 없는 ZMQ 엔벨로프가 리턴되었습니다. " #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "RPC 메시지가 올바르지 않습니다. " #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "%(msg)s" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "메시지를 전송 중인 대상: %s" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "중개인 결과가 없습니다. 캐스트하지 않습니다. " #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "중개자와 일치하지 않습니다. " #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "중개자가 일치를 찾지 못했습니다. " #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "중개자가 등록이나 하트비트를 구현하지 않습니다." #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "하트비트를 시작하기 전에 등록하십시오. " #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "'%s' 주제에 대한 키 정의 호스트가 없습니다. 링 파일 참조" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "%s 서비스에 대한 이용자 연결 작성" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/el/0000775000567000056700000000000012540643116016607 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/el/LC_MESSAGES/0000775000567000056700000000000012540643116020374 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/el/LC_MESSAGES/heat.po0000664000567000056700000050033612540642614021666 0ustar jenkinsjenkins00000000000000# Greek translations for heat. # Copyright (C) 2014 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2014-03-27 23:49+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Greek " "(http://www.transifex.com/projects/p/openstack/language/el/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/es_MX/0000775000567000056700000000000012540643116017222 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/es_MX/LC_MESSAGES/0000775000567000056700000000000012540643116021007 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/es_MX/LC_MESSAGES/heat.po0000664000567000056700000050043012540642614022274 0ustar jenkinsjenkins00000000000000# Spanish (Mexico) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-11 04:52+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Spanish (Mexico) " "(http://www.transifex.com/projects/p/openstack/language/es_MX/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "Ha ocurrido un error desconocido." #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/uk/0000775000567000056700000000000012540643116016626 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/uk/LC_MESSAGES/0000775000567000056700000000000012540643116020413 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/uk/LC_MESSAGES/heat.po0000664000567000056700000050043512540642614021705 0ustar jenkinsjenkins00000000000000# Ukrainian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: uk \n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && " "n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/es/0000775000567000056700000000000012540643116016616 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/es/LC_MESSAGES/0000775000567000056700000000000012540643116020403 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/es/LC_MESSAGES/heat.po0000664000567000056700000050031612540642614021673 0ustar jenkinsjenkins00000000000000# Spanish translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: es \n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/ru/0000775000567000056700000000000012540643116016635 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ru/LC_MESSAGES/0000775000567000056700000000000012540643116020422 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/ru/LC_MESSAGES/heat.po0000664000567000056700000050043312540642614021712 0ustar jenkinsjenkins00000000000000# Russian translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # FIRST AUTHOR , 2013. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: heat 2013.2.a430.gd264018\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: ru \n" "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && " "n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/bn_IN/0000775000567000056700000000000012540643116017174 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/bn_IN/LC_MESSAGES/0000775000567000056700000000000012540643116020761 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/bn_IN/LC_MESSAGES/heat.po0000664000567000056700000050035412540642614022253 0ustar jenkinsjenkins00000000000000# Bengali (India) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-20 01:34+0000\n" "Last-Translator: Tom Fifield \n" "Language-Team: Bengali (India) " "(http://www.transifex.com/projects/p/openstack/language/bn_IN/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/nl_NL/0000775000567000056700000000000012540643116017211 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/nl_NL/LC_MESSAGES/0000775000567000056700000000000012540643116020776 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/nl_NL/LC_MESSAGES/heat.po0000664000567000056700000050037512540642614022273 0ustar jenkinsjenkins00000000000000# Dutch (Netherlands) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-10-10 01:09+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Dutch (Netherlands) " "(http://www.transifex.com/projects/p/openstack/language/nl_NL/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/locale/pa_IN/0000775000567000056700000000000012540643116017175 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pa_IN/LC_MESSAGES/0000775000567000056700000000000012540643116020762 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/locale/pa_IN/LC_MESSAGES/heat.po0000664000567000056700000050041112540642614022246 0ustar jenkinsjenkins00000000000000# Punjabi (Gurmukhi, India) translations for heat. # Copyright (C) 2013 ORGANIZATION # This file is distributed under the same license as the heat project. # # Translators: msgid "" msgstr "" "Project-Id-Version: Heat\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" "POT-Creation-Date: 2014-03-28 06:08+0000\n" "PO-Revision-Date: 2013-12-16 02:54+0000\n" "Last-Translator: openstackjenkins \n" "Language-Team: Panjabi (Punjabi) (India) " "(http://www.transifex.com/projects/p/openstack/language/pa_IN/)\n" "Plural-Forms: nplurals=2; plural=(n != 1)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 1.3\n" #: heat/api/aws/ec2token.py:38 msgid "Authentication Endpoint URI." msgstr "" #: heat/api/aws/ec2token.py:41 heat/common/config.py:148 msgid "Allow orchestration of multiple clouds." msgstr "" #: heat/api/aws/ec2token.py:44 heat/common/config.py:151 msgid "" "Allowed keystone endpoints for auth_uri when multi_cloud is enabled. At " "least one endpoint needs to be specified." msgstr "" #: heat/api/aws/ec2token.py:129 #, python-format msgid "Attempt authorize on %s" msgstr "" #: heat/api/aws/ec2token.py:132 #, python-format msgid "Authorize failed: %s" msgstr "" #: heat/api/aws/ec2token.py:142 msgid "Checking AWS credentials.." msgstr "" #: heat/api/aws/ec2token.py:149 msgid "No AWS Signature found." msgstr "" #: heat/api/aws/ec2token.py:157 msgid "No AWSAccessKeyId/Authorization Credential" msgstr "" #: heat/api/aws/ec2token.py:160 msgid "AWS credentials found, checking against keystone." msgstr "" #: heat/api/aws/ec2token.py:163 msgid "Ec2Token authorization failed, no auth_uri specified in config file" msgstr "" #: heat/api/aws/ec2token.py:165 msgid "Service misconfigured" msgstr "" #: heat/api/aws/ec2token.py:188 #, python-format msgid "Authenticating with %s" msgstr "" #: heat/api/aws/ec2token.py:196 msgid "AWS authentication successful." msgstr "" #: heat/api/aws/ec2token.py:198 msgid "AWS authentication failure." msgstr "" #: heat/api/aws/exception.py:35 msgid "Generic HeatAPIException, please use specific subclasses!" msgstr "" #: heat/api/aws/exception.py:74 msgid "The request signature does not conform to AWS standards" msgstr "" #: heat/api/aws/exception.py:83 msgid "The request processing has failed due to an internal error" msgstr "" #: heat/api/aws/exception.py:94 msgid "The action or operation requested is invalid" msgstr "" #: heat/api/aws/exception.py:103 msgid "The certificate or AWS Key ID provided does not exist" msgstr "" #: heat/api/aws/exception.py:112 msgid "Incompatible parameters were used together" msgstr "" #: heat/api/aws/exception.py:121 msgid "A bad or out-of-range value was supplied" msgstr "" #: heat/api/aws/exception.py:130 msgid "AWS query string is malformed, does not adhere to AWS spec" msgstr "" #: heat/api/aws/exception.py:140 msgid "The query string is malformed" msgstr "" #: heat/api/aws/exception.py:149 msgid "The request is missing an action or operation parameter" msgstr "" #: heat/api/aws/exception.py:159 msgid "Does not contain a valid AWS Access Key or certificate" msgstr "" #: heat/api/aws/exception.py:168 msgid "A mandatory input parameter is missing" msgstr "" #: heat/api/aws/exception.py:177 msgid "The AWS Access Key ID needs a subscription for the service" msgstr "" #: heat/api/aws/exception.py:188 msgid "Request expired or more than 15mins in the future" msgstr "" #: heat/api/aws/exception.py:197 msgid "Service temporarily unavailable" msgstr "" #: heat/api/aws/exception.py:207 msgid "Request was denied due to request throttling" msgstr "" #: heat/api/aws/exception.py:216 msgid "Resource with the name requested already exists" msgstr "" #: heat/api/aws/exception.py:227 msgid "User is not authorized to perform action" msgstr "" #: heat/api/aws/exception.py:237 msgid "" "The request signature we calculated does not match the signature you " "provided" msgstr "" #: heat/api/aws/exception.py:248 msgid "The requested action is not yet implemented" msgstr "" #: heat/api/aws/utils.py:106 #, python-format msgid "Request does not contain %s parameter!" msgstr "" #: heat/api/cfn/v1/stacks.py:55 heat/api/cloudwatch/watch.py:49 #, python-format msgid "Action %s not allowed for user" msgstr "" #: heat/api/cfn/v1/stacks.py:62 heat/api/cloudwatch/watch.py:56 #, python-format msgid "Error authorizing action %s" msgstr "" #: heat/api/cfn/v1/stacks.py:258 #, python-format msgid "Failed to fetch template: %s" msgstr "" #: heat/api/cfn/v1/stacks.py:293 msgid "DisableRollback and OnFailure may not be used together" msgstr "" #: heat/api/cfn/v1/stacks.py:313 #, python-format msgid "Unexpected action %(action)s" msgstr "" #: heat/api/cfn/v1/stacks.py:331 heat/api/cfn/v1/stacks.py:413 msgid "Invalid Template URL" msgstr "" #: heat/api/cfn/v1/stacks.py:335 heat/api/cfn/v1/stacks.py:416 msgid "TemplateBody or TemplateUrl were not given." msgstr "" #: heat/api/cfn/v1/stacks.py:341 heat/api/cfn/v1/stacks.py:422 msgid "The Template must be a JSON or YAML document." msgstr "" #: heat/api/cfn/v1/stacks.py:383 msgid "stack not not found" msgstr "" #: heat/api/cloudwatch/watch.py:215 #, python-format msgid "Invalid filter key %s, ignoring" msgstr "" #: heat/api/cloudwatch/watch.py:224 #, python-format msgid "filter parameters : %s" msgstr "" #: heat/api/cloudwatch/watch.py:270 msgid "Request does not contain required MetricData" msgstr "" #: heat/api/cloudwatch/watch.py:321 #, python-format msgid "Invalid state %(state)s, expecting one of %(expect)s" msgstr "" #: heat/api/cloudwatch/watch.py:328 #, python-format msgid "setting %(name)s to %(state)s" msgstr "" #: heat/api/middleware/version_negotiation.py:50 #, python-format msgid "Processing request: %(method)s %(path)s Accept: %(accept)s" msgstr "" #: heat/api/middleware/version_negotiation.py:65 #, python-format msgid "Matched versioned URI. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:73 #, python-format msgid "" "Unknown version in versioned URI: %(major_version)d.%(minor_version)d. " "Returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:89 #, python-format msgid "Matched versioned media type. Version: %(major_version)d.%(minor_version)d" msgstr "" #: heat/api/middleware/version_negotiation.py:95 #, python-format msgid "" "Unknown version in accept header: " "%(major_version)d.%(minor_version)d...returning version choices." msgstr "" #: heat/api/middleware/version_negotiation.py:103 #, python-format msgid "Unknown accept header: %s...returning HTTP not found." msgstr "" #: heat/api/openstack/v1/actions.py:44 msgid "No action specified" msgstr "" #: heat/api/openstack/v1/actions.py:47 msgid "Multiple actions specified" msgstr "" #: heat/api/openstack/v1/actions.py:51 #, python-format msgid "Invalid action %s specified" msgstr "" #: heat/api/openstack/v1/actions.py:58 #, python-format msgid "Unexpected action %s" msgstr "" #: heat/api/openstack/v1/events.py:104 #, python-format msgid "No events found for resource %s" msgstr "" #: heat/api/openstack/v1/events.py:122 #, python-format msgid "No event %s found" msgstr "" #: heat/api/openstack/v1/stacks.py:74 #, python-format msgid "%(type)s not in valid format: %(error)s" msgstr "" #: heat/api/openstack/v1/stacks.py:82 msgid "No stack name specified" msgstr "" #: heat/api/openstack/v1/stacks.py:100 #, python-format msgid "Could not retrieve template: %s" msgstr "" #: heat/api/openstack/v1/stacks.py:103 msgid "No template specified" msgstr "" #: heat/api/openstack/v1/util.py:62 msgid "Invalid Stack address" msgstr "" #: heat/cmd/manage.py:65 msgid "How long to preserve deleted data." msgstr "" #: heat/cmd/manage.py:69 msgid "Granularity to use for age argument, defaults to days." msgstr "" #: heat/common/auth_url.py:43 msgid "Request missing required header X-Auth-Url" msgstr "" #: heat/common/auth_url.py:47 #, python-format msgid "Header X-Auth-Url \"%s\" not an allowed endpoint" msgstr "" #: heat/common/config.py:36 msgid "The flavor to use." msgstr "" #: heat/common/config.py:38 msgid "The API paste config file to use." msgstr "" #: heat/common/config.py:102 msgid "Select deferred auth method, stored password or trusts." msgstr "" #: heat/common/config.py:106 msgid "Subset of trustor roles to be delegated to heat." msgstr "" #: heat/common/config.py:112 msgid "Maximum number of stacks any one tenant may have active at one time." msgstr "" #: heat/common/config.py:116 msgid "" "Controls how many events will be pruned whenever a stack's events exceed" " max_events_per_stack. Set this lower to keep more events at the expense " "of more frequent purges." msgstr "" #: heat/common/config.py:122 msgid "" "Maximum events that will be available per stack. Older events will be " "deleted when this is reached. Set to 0 for unlimited events per stack." msgstr "" #: heat/common/config.py:127 msgid "RPC timeout for the engine liveness check that is used for stack locking." msgstr "" #: heat/common/config.py:130 msgid "" "onready allows you to send a notification when the heat processes are " "ready to serve. This is either a module with the notify() method or a " "shell command. To enable notifications with systemd, one may use the " "'systemd-notify --ready' shell command or the 'heat.common.systemd' " "notification module." msgstr "" #: heat/common/config.py:157 msgid "" "Type of endpoint in Identity service catalog to use for communication " "with the OpenStack service." msgstr "" #: heat/common/config.py:161 msgid "Optional CA cert file to use in SSL connections." msgstr "" #: heat/common/config.py:163 msgid "Optional PEM-formatted certificate chain file." msgstr "" #: heat/common/config.py:165 msgid "Optional PEM-formatted file that contains the private key." msgstr "" #: heat/common/config.py:169 msgid "If set, then the server's certificate will not be verified." msgstr "" #: heat/common/config.py:184 #, python-format msgid "Optional heat url in format like http://0.0.0.0:8004/v1/%(tenant_id)s." msgstr "" #: heat/common/config.py:194 msgid "" "Heat build revision. If you would prefer to manage your build revision " "separately, you can move this section to a different file and add it as " "another config option." msgstr "" #: heat/common/config.py:223 msgid "" "The \"instance_user\" option in heat.conf is deprecated and will be " "removed in the Juno release." msgstr "" #: heat/common/config.py:270 msgid "Unable to locate config file" msgstr "" #: heat/common/config.py:282 #, python-format msgid "" "Unable to load %(app_name)s from configuration file %(conf_file)s.\n" "Got: %(e)r" msgstr "" #: heat/common/custom_backend_auth.py:45 msgid "Authenticating user token" msgstr "" #: heat/common/custom_backend_auth.py:61 msgid "Backend authentication failed" msgstr "" #: heat/common/environment_format.py:39 msgid "The environment is not a valid YAML mapping data type." msgstr "" #: heat/common/environment_format.py:43 #, python-format msgid "environment has wrong section \"%s\"" msgstr "" #: heat/common/exception.py:102 msgid "An unknown exception occurred." msgstr "" #: heat/common/exception.py:113 heat/openstack/common/rpc/common.py:88 msgid "Exception in string format operation" msgstr "" #: heat/common/exception.py:128 #, python-format msgid "Missing required credential: %(required)s" msgstr "" #: heat/common/exception.py:132 #, python-format msgid "" "Incorrect auth strategy, expected \"%(expected)s\" but received " "\"%(received)s\"" msgstr "" #: heat/common/exception.py:137 #, python-format msgid "Connect error/bad request to Auth service at URL %(url)s." msgstr "" #: heat/common/exception.py:141 #, python-format msgid "Auth service at URL %(url)s not found." msgstr "" #: heat/common/exception.py:145 msgid "Authorization failed." msgstr "" #: heat/common/exception.py:149 msgid "You are not authenticated." msgstr "" #: heat/common/exception.py:153 heat/common/exception.py:158 msgid "You are not authorized to complete this action." msgstr "" #: heat/common/exception.py:162 #, python-format msgid "Data supplied was not valid: %(reason)s" msgstr "" #: heat/common/exception.py:166 #, python-format msgid "Redirecting to %(uri)s for authorization." msgstr "" #: heat/common/exception.py:170 msgid "The URI was too long." msgstr "" #: heat/common/exception.py:174 #, python-format msgid "Maximum redirects (%(redirects)s) was exceeded." msgstr "" #: heat/common/exception.py:178 msgid "Received invalid HTTP redirect." msgstr "" #: heat/common/exception.py:182 #, python-format msgid "" "Multiple 'image' service matches for region %(region)s. This generally " "means that a region is required and you have not supplied one." msgstr "" #: heat/common/exception.py:188 #, python-format msgid "The Parameter (%(key)s) was not provided." msgstr "" #: heat/common/exception.py:192 #, python-format msgid "The Parameter (%(key)s) was not defined in template." msgstr "" #: heat/common/exception.py:196 #, python-format msgid "The template version is invalid: %(explanation)s" msgstr "" #: heat/common/exception.py:200 #, python-format msgid "The Parameter (%(key)s) has no attributes." msgstr "" #: heat/common/exception.py:204 #, python-format msgid "The Referenced Attribute (%(resource)s %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:209 #, python-format msgid "The specified reference \"%(resource)s\" (in %(key)s) is incorrect." msgstr "" #: heat/common/exception.py:214 #, python-format msgid "The Key (%(key_name)s) could not be found." msgstr "" #: heat/common/exception.py:218 #, python-format msgid "The Flavor ID (%(flavor_id)s) could not be found." msgstr "" #: heat/common/exception.py:222 #, python-format msgid "The Image (%(image_name)s) could not be found." msgstr "" #: heat/common/exception.py:226 #, python-format msgid "Multiple physical resources were found with name (%(name)s)." msgstr "" #: heat/common/exception.py:231 #, python-format msgid "Searching Tenant %(target)s from Tenant %(actual)s forbidden." msgstr "" #: heat/common/exception.py:236 #, python-format msgid "The Stack (%(stack_name)s) could not be found." msgstr "" #: heat/common/exception.py:240 #, python-format msgid "The Stack (%(stack_name)s) already exists." msgstr "" #: heat/common/exception.py:244 #, python-format msgid "%(message)s" msgstr "" #: heat/common/exception.py:248 #, python-format msgid "" "The Resource (%(resource_name)s) could not be found in Stack " "%(stack_name)s." msgstr "" #: heat/common/exception.py:253 #, python-format msgid "The Resource Type (%(type_name)s) could not be found." msgstr "" #: heat/common/exception.py:257 #, python-format msgid "The Resource (%(resource_name)s) is not available." msgstr "" #: heat/common/exception.py:261 #, python-format msgid "The Resource (%(resource_id)s) could not be found." msgstr "" #: heat/common/exception.py:265 #, python-format msgid "The Watch Rule (%(watch_name)s) could not be found." msgstr "" #: heat/common/exception.py:269 #, python-format msgid "%(exc_type)s: %(message)s" msgstr "" #: heat/common/exception.py:283 #, python-format msgid "%(feature)s is not supported." msgstr "" #: heat/common/exception.py:287 #, python-format msgid "Cannot define the following properties at the same time: %s." msgstr "" #: heat/common/exception.py:305 msgid "" "Egress rules are only allowed when Neutron is used and the 'VpcId' " "property is set." msgstr "" #: heat/common/exception.py:322 #, python-format msgid "Invalid content type %(content_type)s" msgstr "" #: heat/common/exception.py:326 #, python-format msgid "Request limit exceeded: %(message)s" msgstr "" #: heat/common/exception.py:330 msgid "Maximum resources per stack exceeded." msgstr "" #: heat/common/exception.py:334 #, python-format msgid "Stack %(stack_name)s already has an action (%(action)s) in progress." msgstr "" #: heat/common/exception.py:339 #, python-format msgid "The config (%(software_config_id)s) could not be found." msgstr "" #: heat/common/exception.py:343 #, python-format msgid "Failed to stop stack (%(stack_name)s) on other engine (%(engine_id)s)" msgstr "" #: heat/common/heat_keystoneclient.py:94 msgid "" "heat.conf misconfigured, cannot specify stack_user_domain without " "stack_domain_admin and stack_domain_admin_password" msgstr "" #: heat/common/heat_keystoneclient.py:99 msgid "stack_user_domain ID not set in heat.conf falling back to using default" msgstr "" #: heat/common/heat_keystoneclient.py:101 #, python-format msgid "Using stack domain %s" msgstr "" #: heat/common/heat_keystoneclient.py:161 msgid "Keystone v3 API connection failed, no password trust or auth_token!" msgstr "" #: heat/common/heat_keystoneclient.py:172 msgid "trust token re-scoping failed!" msgstr "" #: heat/common/heat_keystoneclient.py:262 #, python-format msgid "Truncating the username %s to the last 64 characters." msgstr "" #: heat/common/heat_keystoneclient.py:296 #: heat/common/heat_keystoneclient.py:337 #, python-format msgid "Adding user %(user)s to role %(role)s" msgstr "" #: heat/common/heat_keystoneclient.py:301 #: heat/common/heat_keystoneclient.py:342 #, python-format msgid "Failed to add user %(user)s to role %(role)s, check role exists!" msgstr "" #: heat/common/heat_keystoneclient.py:305 #: heat/common/heat_keystoneclient.py:345 #, python-format msgid "Can't find role %s" msgstr "" #: heat/common/heat_keystoneclient.py:321 msgid "" "Falling back to legacy non-domain user create, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:354 #, python-format msgid "User %s in invalid domain" msgstr "" #: heat/common/heat_keystoneclient.py:356 #, python-format msgid "User %s in invalid project" msgstr "" #: heat/common/heat_keystoneclient.py:362 msgid "" "Falling back to legacy non-domain user delete, configure domain in " "heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:376 #: heat/common/heat_keystoneclient.py:393 msgid "Falling back to legacy non-domain project, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:460 #: heat/common/heat_keystoneclient.py:477 msgid "Falling back to legacy non-domain keypair, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:496 msgid "Falling back to legacy non-domain disable, configure domain in heat.conf" msgstr "" #: heat/common/heat_keystoneclient.py:506 msgid "Falling back to legacy non-domain enable, configure domain in heat.conf" msgstr "" #: heat/common/identifier.py:40 msgid "Stack name may not contain \"/\"" msgstr "" #: heat/common/identifier.py:56 #, python-format msgid "\"%s\" is not a valid ARN" msgstr "" #: heat/common/identifier.py:62 #, python-format msgid "\"%s\" is not a valid Heat ARN" msgstr "" #: heat/common/identifier.py:79 #, python-format msgid "\"%s\" is not a valid URL" msgstr "" #: heat/common/identifier.py:85 #, python-format msgid "\"%s\" is not a valid ARN URL" msgstr "" #: heat/common/identifier.py:141 heat/common/identifier.py:148 #, python-format msgid "Unknown attribute \"%s\"" msgstr "" #: heat/common/identifier.py:179 heat/engine/resource.py:142 msgid "Resource name may not contain \"/\"" msgstr "" #: heat/common/notify.py:36 #, python-format msgid "Failed to execute onready command: %s" msgstr "" #: heat/common/plugin_loader.py:93 #, python-format msgid "Failed to import module %s" msgstr "" #: heat/common/short_id.py:44 #, python-format msgid "Invalid UUID version (%d)" msgstr "" #: heat/common/systemd.py:39 msgid "Unable to notify systemd of startup completion: NOTIFY_SOCKET not set" msgstr "" #: heat/common/template_format.py:72 #, python-format msgid "Template exceeds maximum allowed size (%s bytes)" msgstr "" #: heat/common/template_format.py:77 msgid "The template is not a JSON object or YAML mapping." msgstr "" #: heat/common/template_format.py:83 msgid "Template format version not found." msgstr "" #: heat/common/timeutils.py:33 msgid "Only ISO 8601 duration format of the form PT#H#M#S is supported." msgstr "" #: heat/common/urlfetch.py:41 #, python-format msgid "Fetching data from %s" msgstr "" #: heat/common/urlfetch.py:46 #, python-format msgid "Invalid URL scheme %s" msgstr "" #: heat/common/urlfetch.py:52 heat/common/urlfetch.py:76 #, python-format msgid "Failed to retrieve template: %s" msgstr "" #: heat/common/wsgi.py:54 heat/common/wsgi.py:88 heat/common/wsgi.py:122 msgid "" "Address to bind the server. Useful when selecting a particular network " "interface." msgstr "" #: heat/common/wsgi.py:58 heat/common/wsgi.py:92 heat/common/wsgi.py:126 msgid "The port on which the server will listen." msgstr "" #: heat/common/wsgi.py:61 heat/common/wsgi.py:95 heat/common/wsgi.py:129 msgid "Number of backlog requests to configure the socket with." msgstr "" #: heat/common/wsgi.py:65 heat/common/wsgi.py:99 heat/common/wsgi.py:133 msgid "Location of the SSL certificate file to use for SSL mode." msgstr "" #: heat/common/wsgi.py:69 heat/common/wsgi.py:103 heat/common/wsgi.py:137 msgid "Location of the SSL key file to use for enabling SSL mode." msgstr "" #: heat/common/wsgi.py:73 heat/common/wsgi.py:107 heat/common/wsgi.py:141 msgid "Number of workers for Heat service." msgstr "" #: heat/common/wsgi.py:76 heat/common/wsgi.py:110 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs)." msgstr "" #: heat/common/wsgi.py:144 msgid "" "Maximum line size of message headers to be accepted. max_header_line may " "need to be increased when using large tokens (typically those generated " "by the Keystone v3 API with big service catalogs.)" msgstr "" #: heat/common/wsgi.py:204 heat/openstack/common/sslutils.py:59 msgid "" "When running server in SSL mode, you must specify both a cert_file and " "key_file option value in your configuration file" msgstr "" #: heat/common/wsgi.py:222 #, python-format msgid "Could not bind to %(bind_addr)safter trying for 30 seconds" msgstr "" #: heat/common/wsgi.py:254 msgid "SIGTERM received" msgstr "" #: heat/common/wsgi.py:263 msgid "SIGHUP received" msgstr "" #: heat/common/wsgi.py:279 heat/openstack/common/service.py:337 #, python-format msgid "Starting %d workers" msgstr "" #: heat/common/wsgi.py:290 #, python-format msgid "Removing dead child %s" msgstr "" #: heat/common/wsgi.py:297 msgid "Caught keyboard interrupt. Exiting." msgstr "" #: heat/common/wsgi.py:301 msgid "Exited" msgstr "" #: heat/common/wsgi.py:319 #, python-format msgid "Child %d exiting normally" msgstr "" #: heat/common/wsgi.py:322 #, python-format msgid "Started child %s" msgstr "" #: heat/common/wsgi.py:345 msgid "Starting single process server" msgstr "" #: heat/common/wsgi.py:552 #, python-format msgid "" "JSON body size (%(len)s bytes) exceeds maximum allowed size (%(limit)s " "bytes)." msgstr "" #: heat/common/wsgi.py:678 #, python-format msgid "Exception handling resource: %s" msgstr "" #: heat/common/wsgi.py:679 msgid "" "The server could not comply with the request since\r\n" "it is either malformed or otherwise incorrect.\r\n" msgstr "" #: heat/common/wsgi.py:695 #, python-format msgid "Returning %(code)s to user: %(explanation)s" msgstr "" #: heat/common/wsgi.py:735 msgid "Unable to serialize exception response" msgstr "" #: heat/common/wsgi.py:770 #, python-format msgid "Unexpected error occurred serving API: %s" msgstr "" #: heat/db/sqlalchemy/api.py:77 #, python-format msgid "raw template with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:94 #, python-format msgid "resource with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:124 msgid "no resources were found" msgstr "" #: heat/db/sqlalchemy/api.py:138 msgid "no resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:188 msgid "No resource data found" msgstr "" #: heat/db/sqlalchemy/api.py:241 #, python-format msgid "no resources for stack_id %s were found" msgstr "" #: heat/db/sqlalchemy/api.py:382 #, python-format msgid "Attempt to update a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:394 #, python-format msgid "Attempt to delete a stack with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:477 #, python-format msgid "Attempt to delete user creds with id %(id)s that does not exist" msgstr "" #: heat/db/sqlalchemy/api.py:592 #, python-format msgid "Attempt to update a watch with id: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:604 #, python-format msgid "Attempt to delete watch_rule: %(id)s %(msg)s" msgstr "" #: heat/db/sqlalchemy/api.py:643 #, python-format msgid "Software config with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:670 #, python-format msgid "Deployment with id %s not found" msgstr "" #: heat/db/sqlalchemy/api.py:706 msgid "age should be an integer" msgstr "" #: heat/db/sqlalchemy/api.py:708 msgid "age should be a positive integer" msgstr "" #: heat/db/sqlalchemy/api.py:712 msgid "granularity should be days, hours, minutes, or seconds" msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/029_event_id_to_uuid.py:40 msgid "" "If you really want to downgrade to this version, you should drop all the " "records." msgstr "" #: heat/db/sqlalchemy/migrate_repo/versions/037_migrate_hot_template.py:56 #: heat/db/sqlalchemy/migrate_repo/versions/041_migrate_hot_template_resources.py:69 #: heat/db/sqlalchemy/migrate_repo/versions/043_migrate_template_versions.py:57 msgid "" "This version cannot be downgraded because it involves a data migration to" " the raw_template table." msgstr "" #: heat/engine/api.py:35 msgid "create timeout conversion" msgstr "" #: heat/engine/api.py:47 #, python-format msgid "Unexpected value for parameter %(name)s : %(value)s" msgstr "" #: heat/engine/api.py:57 #, python-format msgid "Unexpected adopt data \"%s\". Adopt data must be a dict." msgstr "" #: heat/engine/api.py:233 msgid "Unexpected number of keys in watch_data.data!" msgstr "" #: heat/engine/attributes.py:84 #, python-format msgid "%(resource)s: Invalid attribute %(key)s" msgstr "" #: heat/engine/clients.py:33 msgid "swiftclient not available" msgstr "" #: heat/engine/clients.py:38 msgid "neutronclient not available" msgstr "" #: heat/engine/clients.py:43 msgid "cinderclient not available" msgstr "" #: heat/engine/clients.py:49 msgid "troveclient not available" msgstr "" #: heat/engine/clients.py:55 msgid "ceilometerclient not available" msgstr "" #: heat/engine/clients.py:104 msgid "Nova connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:141 msgid "Swift connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:169 msgid "Neutron connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:196 msgid "Cinder connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:227 msgid "Trove connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:257 msgid "Ceilometer connection failed, no auth_token!" msgstr "" #: heat/engine/clients.py:304 msgid "Heat connection failed, no auth_token!" msgstr "" #: heat/engine/constraints.py:84 #, python-format msgid "Invalid type (%s)" msgstr "" #: heat/engine/constraints.py:91 #, python-format msgid "Single schema valid only for %(ltype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:101 #, python-format msgid "Schema valid only for %(ltype)s or %(mtype)s, not %(utype)s" msgstr "" #: heat/engine/constraints.py:110 #, python-format msgid "%(name)s constraint invalid for %(utype)s" msgstr "" #: heat/engine/constraints.py:124 heat/engine/parameters.py:83 #, python-format msgid "Invalid default %(default)s (%(exc)s)" msgstr "" #: heat/engine/constraints.py:200 #, python-format msgid "Invalid key %s" msgstr "" #: heat/engine/constraints.py:289 msgid "min/max must be numeric" msgstr "" #: heat/engine/constraints.py:293 msgid "A range constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:298 #, python-format msgid "The value must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:300 #, python-format msgid "The value must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:302 #, python-format msgid "The value must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:350 msgid "A length constraint must have a min value and/or a max value specified." msgstr "" #: heat/engine/constraints.py:357 msgid "min/max length must be integral" msgstr "" #: heat/engine/constraints.py:362 #, python-format msgid "The length must be at least %(min)s." msgstr "" #: heat/engine/constraints.py:364 #, python-format msgid "The length must be no greater than %(max)s." msgstr "" #: heat/engine/constraints.py:366 #, python-format msgid "The length must be in the range %(min)s to %(max)s." msgstr "" #: heat/engine/constraints.py:397 msgid "AllowedValues must be a list" msgstr "" #: heat/engine/constraints.py:402 #, python-format msgid "Allowed values: %s" msgstr "" #: heat/engine/constraints.py:437 msgid "AllowedPattern must be a string" msgstr "" #: heat/engine/constraints.py:442 #, python-format msgid "Value must match pattern: %s" msgstr "" #: heat/engine/constraints.py:484 #, python-format msgid "Value must be of type %s" msgstr "" #: heat/engine/constraints.py:490 #, python-format msgid "\"%(value)s\" does not validate %(name)s (constraint not found)" msgstr "" #: heat/engine/constraints.py:497 #, python-format msgid "\"%(value)s\" does not validate %(name)s" msgstr "" #: heat/engine/dependencies.py:26 #, python-format msgid "Circular Dependency Found: %(cycle)s" msgstr "" #: heat/engine/environment.py:193 heat/engine/environment.py:199 #, python-format msgid "Removing %(item)s from %(path)s" msgstr "" #: heat/engine/environment.py:212 #, python-format msgid "Changing %(path)s from %(was)s to %(now)s" msgstr "" #: heat/engine/environment.py:214 #, python-format msgid "Registering %(path)s -> %(value)s" msgstr "" #: heat/engine/environment.py:285 heat/tests/test_resource.py:85 #, python-format msgid "Resource \"%s\" has no type" msgstr "" #: heat/engine/environment.py:288 heat/tests/test_resource.py:102 #, python-format msgid "Non-empty resource type is required for resource \"%s\"" msgstr "" #: heat/engine/environment.py:292 heat/tests/test_resource.py:93 #, python-format msgid "Resource \"%s\" type is not a string" msgstr "" #: heat/engine/environment.py:298 #, python-format msgid "Unknown resource Type : %s" msgstr "" #: heat/engine/environment.py:401 #, python-format msgid "Failed to read %s" msgstr "" #: heat/engine/environment.py:408 #, python-format msgid "Loading %s" msgstr "" #: heat/engine/environment.py:413 #, python-format msgid "Failed to parse %(file_path)s" msgstr "" #: heat/engine/environment.py:417 #, python-format msgid "Failed to read %(file_path)s" msgstr "" #: heat/engine/event.py:59 #, python-format msgid "No event exists with id \"%s\"" msgstr "" #: heat/engine/event.py:90 msgid "Duplicating event" msgstr "" #: heat/engine/parameter_groups.py:42 msgid "Validating Parameter Groups." msgstr "" #: heat/engine/parameter_groups.py:51 heat/tests/test_validate.py:1195 msgid "Parameters must be provided for each Parameter Group." msgstr "" #: heat/engine/parameter_groups.py:58 #, python-format msgid "The %s parameter must be assigned to one Parameter Group only." msgstr "" #: heat/engine/parameter_groups.py:66 #, python-format msgid "The Parameter name (%s) does not reference an existing parameter." msgstr "" #: heat/engine/parameters.py:77 #, python-format msgid "Default must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:103 #, python-format msgid "Invalid %s, expected a mapping" msgstr "" #: heat/engine/parameters.py:107 #, python-format msgid "Invalid key '%(key)s' for %(entity)s" msgstr "" #: heat/engine/parameters.py:115 msgid "Missing parameter type" msgstr "" #: heat/engine/parameters.py:185 #, python-format msgid "Invalid Parameter type \"%s\"" msgstr "" #: heat/engine/parameters.py:214 #, python-format msgid "Missing parameter %s" msgstr "" #: heat/engine/parameters.py:293 #, python-format msgid "Value must be a comma-delimited list string: %s" msgstr "" #: heat/engine/parameters.py:329 #, python-format msgid "Value must be valid JSON: %s" msgstr "" #: heat/engine/parameters.py:445 heat/engine/hot/parameters.py:135 msgid "Stack ID" msgstr "" #: heat/engine/parameters.py:449 heat/engine/hot/parameters.py:140 msgid "Stack Name" msgstr "" #: heat/engine/parser.py:73 #, python-format msgid "" "Invalid stack name %s must contain only alphanumeric or \"_-.\" " "characters, must start with alpha" msgstr "" #: heat/engine/parser.py:166 msgid "Unable to set parameters StackId identifier" msgstr "" #: heat/engine/parser.py:185 #, python-format msgid "No stack exists with id \"%s\"" msgstr "" #: heat/engine/parser.py:347 heat/engine/parser.py:348 #, python-format msgid "Duplicate names %s" msgstr "" #: heat/engine/parser.py:375 heat/engine/resource.py:813 #, python-format msgid "Invalid action %s" msgstr "" #: heat/engine/parser.py:378 heat/engine/resource.py:816 #, python-format msgid "Invalid status %s" msgstr "" #: heat/engine/parser.py:488 msgid "Loaded existing backup stack" msgstr "" #: heat/engine/parser.py:496 msgid "Created new backup stack" msgstr "" #: heat/engine/parser.py:536 #, python-format msgid "Unexpected action %s passed to update!" msgstr "" #: heat/engine/parser.py:545 #, python-format msgid "Starting update rollback for %s" msgstr "" #: heat/engine/parser.py:595 msgid "Deleting backup stack" msgstr "" #: heat/engine/parser.py:618 #, python-format msgid "Unexpected action %s passed to delete!" msgstr "" #: heat/engine/parser.py:698 #, python-format msgid "%s is already suspended" msgstr "" #: heat/engine/parser.py:717 #, python-format msgid "%s is already resumed" msgstr "" #: heat/engine/parser.py:745 #, python-format msgid "delete: %s" msgstr "" #: heat/engine/parser.py:753 msgid "create" msgstr "" #: heat/engine/plugin_manager.py:97 #, python-format msgid "Failed to load %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/plugin_manager.py:104 #, python-format msgid "Invalid type for %(mapping_name)s from %(module)s" msgstr "" #: heat/engine/properties.py:74 #, python-format msgid "Unknown key(s) %s" msgstr "" #: heat/engine/properties.py:95 #, python-format msgid "No %s specified" msgstr "" #: heat/engine/properties.py:104 #, python-format msgid "%(schema)s supplied for %(type)s %(data)s" msgstr "" #: heat/engine/properties.py:199 #, python-format msgid "Value '%s' is not an integer" msgstr "" #: heat/engine/properties.py:212 msgid "Value must be a string" msgstr "" #: heat/engine/properties.py:232 #, python-format msgid "\"%s\" is not a map" msgstr "" #: heat/engine/properties.py:241 #, python-format msgid "\"%s\" is not a list" msgstr "" #: heat/engine/properties.py:253 #, python-format msgid "\"%s\" is not a valid boolean" msgstr "" #: heat/engine/properties.py:312 #, python-format msgid "Property error : %s" msgstr "" #: heat/engine/properties.py:317 #, python-format msgid "Property %s not implemented yet" msgstr "" #: heat/engine/properties.py:322 #, python-format msgid "Unknown Property %s" msgstr "" #: heat/engine/properties.py:327 #, python-format msgid "%(prefix)sInvalid Property %(key)s" msgstr "" #: heat/engine/properties.py:343 #, python-format msgid "%(prefix)sProperty %(key)s not assigned" msgstr "" #: heat/engine/resource.py:58 heat/engine/resource.py:61 #, python-format msgid "The Resource %s requires replacement." msgstr "" #: heat/engine/resource.py:433 msgid "Error marking resource as failed" msgstr "" #: heat/engine/resource.py:452 #, python-format msgid "State %s invalid for create" msgstr "" #: heat/engine/resource.py:490 msgid "Resource ID was not provided." msgstr "" #: heat/engine/resource.py:536 msgid "Resource update already requested" msgstr "" #: heat/engine/resource.py:560 #, python-format msgid "Resource %s update requires replacement" msgstr "" #: heat/engine/resource.py:581 #, python-format msgid "State %s invalid for suspend" msgstr "" #: heat/engine/resource.py:585 #, python-format msgid "suspending %s" msgstr "" #: heat/engine/resource.py:597 #, python-format msgid "State %s invalid for resume" msgstr "" #: heat/engine/resource.py:601 #, python-format msgid "resuming %s" msgstr "" #: heat/engine/resource.py:637 msgid "limit cannot be less than 4" msgstr "" #: heat/engine/resource.py:643 #, python-format msgid "Validating %s" msgstr "" #: heat/engine/resource.py:652 #, python-format msgid "Invalid DeletionPolicy %s" msgstr "" #: heat/engine/resource.py:656 msgid "Snapshot DeletionPolicy not supported" msgstr "" #: heat/engine/resource.py:674 #, python-format msgid "deleting %s" msgstr "" #: heat/engine/resource.py:696 #, python-format msgid "Delete %s" msgstr "" #: heat/engine/resource.py:706 msgid "Error marking resource deletion failed" msgstr "" #: heat/engine/resource.py:737 #, python-format msgid "db error %s" msgstr "" #: heat/engine/resource.py:756 heat/engine/resource.py:767 #: heat/engine/resource.py:784 #, python-format msgid "DB error %s" msgstr "" #: heat/engine/resource.py:888 #, python-format msgid "Resource %s is not able to receive a signal" msgstr "" #: heat/engine/resource.py:895 #, python-format msgid "signal %(name)s : %(msg)s" msgstr "" #: heat/engine/resource.py:908 #, python-format msgid "Resource %s does not implement metadata update" msgstr "" #: heat/engine/scheduler.py:63 #, python-format msgid "%s Timed out" msgstr "" #: heat/engine/scheduler.py:130 #, python-format msgid "%s sleeping" msgstr "" #: heat/engine/scheduler.py:153 #, python-format msgid "%s starting" msgstr "" #: heat/engine/scheduler.py:165 #, python-format msgid "%s done (not resumable)" msgstr "" #: heat/engine/scheduler.py:176 #, python-format msgid "%s timed out" msgstr "" #: heat/engine/scheduler.py:186 #, python-format msgid "%s running" msgstr "" #: heat/engine/scheduler.py:192 #, python-format msgid "%s complete" msgstr "" #: heat/engine/scheduler.py:209 #, python-format msgid "%s cancelled" msgstr "" #: heat/engine/service.py:197 #, python-format msgid "Periodic watcher task for stack %s" msgstr "" #: heat/engine/service.py:201 #, python-format msgid "Unable to retrieve stack %s for periodic task" msgstr "" #: heat/engine/service.py:215 #, python-format msgid "periodic_task db error (%(msg)s) %(ex)s" msgstr "" #: heat/engine/service.py:289 #, python-format msgid "Starting listener for engine %s" msgstr "" #: heat/engine/service.py:439 #, python-format msgid "" "You have reached the maximum stacks per tenant, %d. Please delete some " "stacks." msgstr "" #: heat/engine/service.py:464 #, python-format msgid "previewing stack %s" msgstr "" #: heat/engine/service.py:492 heat/engine/service.py:545 #, python-format msgid "template is %s" msgstr "" #: heat/engine/service.py:506 #, python-format msgid "Stack create failed, status %s" msgstr "" #: heat/engine/service.py:553 msgid "Updating a stack when it is suspended" msgstr "" #: heat/engine/service.py:557 msgid "Updating a stack when another action is in progress" msgstr "" #: heat/engine/service.py:592 msgid "validate_template" msgstr "" #: heat/engine/service.py:594 msgid "No Template provided." msgstr "" #: heat/engine/service.py:687 #, python-format msgid "Deleting stack %s" msgstr "" #: heat/engine/service.py:707 #, python-format msgid "Successfully stopped remote task on engine %s" msgstr "" #: heat/engine/service.py:739 #, python-format msgid "abandoning stack %s" msgstr "" #: heat/engine/service.py:854 #, python-format msgid "Access denied to resource %s" msgstr "" #: heat/engine/service.py:935 #, python-format msgid "suspending stack %s" msgstr "" #: heat/engine/service.py:950 #, python-format msgid "resuming stack %s" msgstr "" #: heat/engine/service.py:1033 #, python-format msgid "show_watch (all) db error %s" msgstr "" #: heat/engine/service.py:1056 msgid "Filtering by namespace/metric not yet supported" msgstr "" #: heat/engine/service.py:1062 #, python-format msgid "show_metric (all) db error %s" msgstr "" #: heat/engine/service.py:1124 msgid "server_id must be specified" msgstr "" #: heat/engine/signal_responder.py:79 msgid "Cannot generate signed url, no stored access/secret key" msgstr "" #: heat/engine/stack_lock.py:69 #, python-format msgid "Engine %(engine)s acquired lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:76 #, python-format msgid "Lock on stack %(stack)s is owned by engine %(engine)s" msgstr "" #: heat/engine/stack_lock.py:82 #, python-format msgid "" "Stale lock detected on stack %(stack)s. Engine %(engine)s will attempt " "to steal the lock" msgstr "" #: heat/engine/stack_lock.py:90 #, python-format msgid "Engine %(engine)s successfully stole the lock on stack %(stack)s" msgstr "" #: heat/engine/stack_lock.py:97 #, python-format msgid "" "The lock on stack %(stack)s was released while engine %(engine)s was " "stealing it. Trying again" msgstr "" #: heat/engine/stack_lock.py:104 #, python-format msgid "" "Failed to steal lock on stack %(stack)s. Engine %(engine)s stole the lock" " first" msgstr "" #: heat/engine/stack_lock.py:117 #, python-format msgid "Lock was already released on stack %s!" msgstr "" #: heat/engine/stack_lock.py:120 #, python-format msgid "Engine %(engine)s released lock on stack %(stack)s" msgstr "" #: heat/engine/stack_resource.py:70 msgid "Nested stack not found in DB" msgstr "" #: heat/engine/stack_resource.py:107 #, python-format msgid "Preview of '%s' not yet implemented" msgstr "" #: heat/engine/stack_resource.py:136 #, python-format msgid "Recursion depth exceeds %d." msgstr "" #: heat/engine/stack_resource.py:188 #, python-format msgid "Cannot update %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:228 #, python-format msgid "Nested stack UPDATE failed: %s" msgstr "" #: heat/engine/stack_resource.py:239 msgid "Stack not found to delete" msgstr "" #: heat/engine/stack_resource.py:262 #, python-format msgid "Cannot suspend %s, stack not created" msgstr "" #: heat/engine/stack_resource.py:284 #, python-format msgid "Cannot resume %s, stack not created" msgstr "" #: heat/engine/stack_user.py:86 msgid "Reverting to legacy user delete path" msgstr "" #: heat/engine/stack_user.py:123 #, python-format msgid "Error creating ec2 keypair for user %s" msgstr "" #: heat/engine/support.py:29 #, python-format msgid "Specified status is invalid, defaulting to %s" msgstr "" #: heat/engine/template.py:67 #, python-format msgid "Ambiguous versions (%s)" msgstr "" #: heat/engine/template.py:88 #, python-format msgid "Unknown version (%(version)s). Should be one of: %(available)s" msgstr "" #: heat/engine/update.py:82 #, python-format msgid "Deleting backup resource %s" msgstr "" #: heat/engine/update.py:106 #, python-format msgid "Swapping in backup Resource %s" msgstr "" #: heat/engine/update.py:112 #, python-format msgid "Deleting backup Resource %s" msgstr "" #: heat/engine/update.py:117 #, python-format msgid "Backing up existing Resource %s" msgstr "" #: heat/engine/update.py:137 #, python-format msgid "Resource %(res_name)s for stack %(stack_name)s updated" msgstr "" #: heat/engine/watchrule.py:78 #, python-format msgid "WatchRule.load (%(watch_name)s) db error %(ex)s" msgstr "" #: heat/engine/watchrule.py:213 #, python-format msgid "ignoring %s" msgstr "" #: heat/engine/watchrule.py:250 #, python-format msgid "WATCH: stack:%(stack)s, watch_name:%(watch_name)s, new_state:%(new_state)s" msgstr "" #: heat/engine/watchrule.py:256 #, python-format msgid "no action for new state %s" msgstr "" #: heat/engine/watchrule.py:266 #, python-format msgid "Could not process watch state %s for stack" msgstr "" #: heat/engine/watchrule.py:287 #, python-format msgid "new sample:%(k)s data:%(sample)s" msgstr "" #: heat/engine/watchrule.py:300 #, python-format msgid "Ignoring metric data for %s, SUSPENDED state" msgstr "" #: heat/engine/watchrule.py:310 #, python-format msgid "Ignoring metric data (only accept %(metric)s) : %(data)s" msgstr "" #: heat/engine/watchrule.py:320 #, python-format msgid "new watch:%(name)s data:%(data)s" msgstr "" #: heat/engine/watchrule.py:328 #, python-format msgid "Invalid watch state %s" msgstr "" #: heat/engine/watchrule.py:340 #, python-format msgid "Unknown watch state %s" msgstr "" #: heat/engine/watchrule.py:346 #, python-format msgid "Overriding state %(self_state)s for watch %(name)s with %(state)s" msgstr "" #: heat/engine/watchrule.py:351 #, python-format msgid "Unable to override state %(state)s for watch %(name)s" msgstr "" #: heat/engine/cfn/functions.py:148 #, python-format msgid "Arguments to \"%s\" must be of the form [resource_name, attribute]" msgstr "" #: heat/engine/cfn/functions.py:196 #, python-format msgid "Arguments to \"%s\" must be of the form [index, collection]" msgstr "" #: heat/engine/cfn/functions.py:222 #, python-format msgid "\"%(fn_name)s\": %(err)s" msgstr "" #: heat/engine/cfn/functions.py:226 #, python-format msgid "Index to \"%s\" must be a string" msgstr "" #: heat/engine/cfn/functions.py:233 #, python-format msgid "Index to \"%s\" must be an integer" msgstr "" #: heat/engine/cfn/functions.py:244 #, python-format msgid "Arguments to %s not fully resolved" msgstr "" #: heat/engine/cfn/functions.py:269 heat/engine/cfn/functions.py:275 #: heat/engine/cfn/functions.py:320 heat/engine/cfn/functions.py:326 #: heat/engine/cfn/functions.py:379 heat/engine/cfn/functions.py:385 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be: %(example)s" msgstr "" #: heat/engine/cfn/functions.py:282 #, python-format msgid "\"%s\" must operate on a list" msgstr "" #: heat/engine/cfn/functions.py:286 #, python-format msgid "\"%s\" delimiter must be a string" msgstr "" #: heat/engine/cfn/functions.py:293 msgid "Items to join must be strings" msgstr "" #: heat/engine/cfn/functions.py:333 #, python-format msgid "Delimiter for %s must be string" msgstr "" #: heat/engine/cfn/functions.py:336 #, python-format msgid "String to split must be string; got %s" msgstr "" #: heat/engine/cfn/functions.py:367 #, python-format msgid "\"%s\" parameters must be a mapping" msgstr "" #: heat/engine/cfn/functions.py:395 #, python-format msgid "\"%s\" template must be a string" msgstr "" #: heat/engine/cfn/functions.py:398 #, python-format msgid "\"%s\" params must be a map" msgstr "" #: heat/engine/cfn/functions.py:404 #, python-format msgid "\"%s\" param placeholders must be strings" msgstr "" #: heat/engine/cfn/functions.py:411 #, python-format msgid "\"%s\" params must be strings or numbers" msgstr "" #: heat/engine/cfn/functions.py:435 #, python-format msgid "\"%s\" argument must be a string" msgstr "" #: heat/engine/cfn/functions.py:470 #, python-format msgid "Wrong Arguments try: \"%s\"" msgstr "" #: heat/engine/cfn/functions.py:473 #, python-format msgid "%s Key Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:476 #, python-format msgid "%s Value Name must be a string" msgstr "" #: heat/engine/cfn/functions.py:482 msgid "Member list must be a list" msgstr "" #: heat/engine/cfn/functions.py:486 msgid "Member list items must be strings" msgstr "" #: heat/engine/cfn/functions.py:521 #, python-format msgid "Incorrect arguments to \"%(fn_name)s\" should be one of: %(allowed)s" msgstr "" #: heat/engine/cfn/functions.py:538 #, python-format msgid "\"%(fn_name)s\" key \"%(key)s\" not found" msgstr "" #: heat/engine/cfn/template.py:32 heat/engine/hot/template.py:49 #: heat/engine/hot/template.py:53 #, python-format msgid "\"%s\" is not a valid template section" msgstr "" #: heat/engine/cfn/template.py:35 heat/engine/hot/template.py:56 #, python-format msgid "Section %s can not be accessed directly." msgstr "" #: heat/engine/hot/functions.py:47 #, python-format msgid "Function \"%s\" must have arguments" msgstr "" #: heat/engine/hot/functions.py:57 #, python-format msgid "Argument to \"%s\" must be string or list" msgstr "" #: heat/engine/hot/functions.py:61 #, python-format msgid "Parameter name in \"%s\" must be string" msgstr "" #: heat/engine/hot/functions.py:72 heat/engine/hot/functions.py:124 #, python-format msgid "\"%s\" can't traverse path" msgstr "" #: heat/engine/hot/functions.py:75 heat/engine/hot/functions.py:127 #, python-format msgid "Path components in \"%s\" must be strings" msgstr "" #: heat/engine/hot/functions.py:102 #, python-format msgid "Argument to \"%s\" must be a list" msgstr "" #: heat/engine/hot/functions.py:106 #, python-format msgid "" "Arguments to \"%s\" must be of the form [resource_name, attribute, " "(path), ...]" msgstr "" #: heat/engine/hot/functions.py:161 #, python-format msgid "Arguments to \"%s\" must be a map" msgstr "" #: heat/engine/hot/functions.py:173 #, python-format msgid "\"str_replace\" syntax should be %s" msgstr "" #: heat/engine/hot/functions.py:194 #, python-format msgid "Argument to \"%s\" must be a string" msgstr "" #: heat/engine/hot/functions.py:201 #, python-format msgid "" "No content found in the \"files\" section for %(fn_name)s path: " "%(file_key)s" msgstr "" #: heat/engine/hot/parameters.py:68 msgid "Invalid parameter constraints, expected a list" msgstr "" #: heat/engine/hot/parameters.py:100 msgid "No constraint expressed" msgstr "" #: heat/engine/hot/template.py:107 #, python-format msgid "\"%s\" is not a valid keyword inside a resource definition" msgstr "" #: heat/engine/hot/template.py:127 #, python-format msgid "\"%s\" is not a valid keyword inside an output definition" msgstr "" #: heat/engine/resources/autoscaling.py:103 #: heat/engine/resources/autoscaling.py:462 #: heat/engine/resources/autoscaling.py:495 #: heat/engine/resources/autoscaling.py:500 #: heat/engine/resources/autoscaling.py:783 #: heat/engine/resources/autoscaling.py:788 #: heat/engine/resources/autoscaling.py:793 #: heat/engine/resources/instance.py:173 heat/engine/resources/instance.py:178 #: heat/engine/resources/instance.py:183 heat/engine/resources/instance.py:188 #: heat/engine/resources/instance.py:193 heat/engine/resources/instance.py:198 #: heat/engine/resources/instance.py:215 heat/engine/resources/instance.py:259 #: heat/engine/resources/loadbalancer.py:310 #: heat/engine/resources/loadbalancer.py:315 #: heat/engine/resources/loadbalancer.py:324 #: heat/engine/resources/loadbalancer.py:329 #: heat/engine/resources/loadbalancer.py:334 #: heat/engine/resources/loadbalancer.py:339 heat/engine/resources/user.py:48 #: heat/engine/resources/user.py:52 heat/engine/resources/user.py:139 #: heat/engine/resources/user.py:149 msgid "Not Implemented." msgstr "" #: heat/engine/resources/autoscaling.py:108 #: heat/engine/resources/autoscaling.py:467 msgid "Name of LaunchConfiguration resource." msgstr "" #: heat/engine/resources/autoscaling.py:114 msgid "Desired number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:120 #: heat/engine/resources/autoscaling.py:508 msgid "List of LoadBalancer resources." msgstr "" #: heat/engine/resources/autoscaling.py:124 #: heat/engine/resources/autoscaling.py:516 msgid "Tags to attach to this group." msgstr "" #: heat/engine/resources/autoscaling.py:144 msgid "A comma-delimited list of server ip addresses. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:403 #, python-format msgid "Unsupported resource '%s' in LoadBalancerNames" msgstr "" #: heat/engine/resources/autoscaling.py:473 msgid "Maximum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:479 msgid "Minimum number of instances in the group." msgstr "" #: heat/engine/resources/autoscaling.py:485 #: heat/engine/resources/autoscaling.py:853 #: heat/engine/resources/autoscaling.py:954 #: heat/engine/resources/autoscaling.py:1094 msgid "Cooldown period, in seconds." msgstr "" #: heat/engine/resources/autoscaling.py:490 msgid "Desired initial number of instances." msgstr "" #: heat/engine/resources/autoscaling.py:512 msgid "List of VPC subnet identifiers." msgstr "" #: heat/engine/resources/autoscaling.py:620 #, python-format msgid "%(name)s NOT performing scaling adjustment, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:647 #, python-format msgid "truncating growth to %s" msgstr "" #: heat/engine/resources/autoscaling.py:650 #, python-format msgid "can not exceed %s" msgstr "" #: heat/engine/resources/autoscaling.py:654 #, python-format msgid "truncating shrinkage to %s" msgstr "" #: heat/engine/resources/autoscaling.py:657 #, python-format msgid "can not be less than %s" msgstr "" #: heat/engine/resources/autoscaling.py:661 #, python-format msgid "no change in capacity %d" msgstr "" #: heat/engine/resources/autoscaling.py:671 #, python-format msgid "Start resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:686 msgid "Failed sending error notification" msgstr "" #: heat/engine/resources/autoscaling.py:691 #, python-format msgid "End resizing the group %(group)s" msgstr "" #: heat/engine/resources/autoscaling.py:719 msgid "MinSize can not be greater than MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:723 msgid "The size of AutoScalingGroup can not be less than zero" msgstr "" #: heat/engine/resources/autoscaling.py:729 msgid "DesiredCapacity must be between MinSize and MaxSize" msgstr "" #: heat/engine/resources/autoscaling.py:738 msgid "Anything other than one VPCZoneIdentifier" msgstr "" #: heat/engine/resources/autoscaling.py:761 #: heat/engine/resources/instance.py:146 msgid "Glance image ID or name." msgstr "" #: heat/engine/resources/autoscaling.py:766 #: heat/engine/resources/instance.py:156 msgid "Nova instance type (flavor)." msgstr "" #: heat/engine/resources/autoscaling.py:771 #: heat/engine/resources/instance.py:162 msgid "Optional Nova keypair name." msgstr "" #: heat/engine/resources/autoscaling.py:775 #: heat/engine/resources/instance.py:267 msgid "User data to pass to instance." msgstr "" #: heat/engine/resources/autoscaling.py:779 #: heat/engine/resources/instance.py:203 msgid "Security group names to assign." msgstr "" #: heat/engine/resources/autoscaling.py:798 #: heat/engine/resources/instance.py:242 msgid "Scheduler hints to pass to Nova (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:831 msgid "" "Resource definition for the resources in the group, in HOT format. The " "value of this property is the definition of a resource just as if it had " "been declared in the template itself." msgstr "" #: heat/engine/resources/autoscaling.py:839 msgid "Maximum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:846 msgid "Minimum number of resources in the group." msgstr "" #: heat/engine/resources/autoscaling.py:858 msgid "Desired initial number of resources." msgstr "" #: heat/engine/resources/autoscaling.py:932 msgid "AutoScaling group name to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:937 #: heat/engine/resources/autoscaling.py:1077 msgid "Size of adjustment." msgstr "" #: heat/engine/resources/autoscaling.py:943 #: heat/engine/resources/autoscaling.py:1083 msgid "Type of adjustment (absolute or percentage)." msgstr "" #: heat/engine/resources/autoscaling.py:962 msgid "A signed url to handle the alarm. (Heat extension)." msgstr "" #: heat/engine/resources/autoscaling.py:987 #: heat/engine/resources/instance.py:72 heat/tests/generic_resource.py:115 #, python-format msgid "Cannot signal resource during %s" msgstr "" #: heat/engine/resources/autoscaling.py:1004 #: heat/engine/resources/instance.py:80 #, python-format msgid "%(name)s Alarm, new state %(state)s" msgstr "" #: heat/engine/resources/autoscaling.py:1010 #, python-format msgid "%(name)s NOT performing scaling action, cooldown %(cooldown)s" msgstr "" #: heat/engine/resources/autoscaling.py:1019 #, python-format msgid "Alarm %(alarm)s could not find scaling group named \"%(group)s\"" msgstr "" #: heat/engine/resources/autoscaling.py:1024 #, python-format msgid "" "%(name)s Alarm, adjusting Group %(group)s with id %(asgn_id)s by " "%(filter)s" msgstr "" #: heat/engine/resources/autoscaling.py:1072 msgid "AutoScaling group ID to apply policy to." msgstr "" #: heat/engine/resources/autoscaling.py:1102 msgid "A signed url to handle the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:42 msgid "Operator used to compare the specified Statistic with Threshold." msgstr "" #: heat/engine/resources/cloud_watch.py:54 #: heat/engine/resources/ceilometer/alarm.py:34 msgid "Description for the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:59 #: heat/engine/resources/ceilometer/alarm.py:116 msgid "Number of periods to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:64 msgid "Metric name watched by the alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:68 msgid "Namespace for the metric." msgstr "" #: heat/engine/resources/cloud_watch.py:72 #: heat/engine/resources/ceilometer/alarm.py:126 msgid "Period (seconds) to evaluate over." msgstr "" #: heat/engine/resources/cloud_watch.py:77 msgid "Metric statistic to evaluate." msgstr "" #: heat/engine/resources/cloud_watch.py:86 msgid "A list of actions to execute when state transitions to alarm." msgstr "" #: heat/engine/resources/cloud_watch.py:91 msgid "A list of actions to execute when state transitions to ok." msgstr "" #: heat/engine/resources/cloud_watch.py:96 msgid "" "A list of dimensions (arbitrary name/value pairs) associated with the " "metric." msgstr "" #: heat/engine/resources/cloud_watch.py:101 msgid "A list of actions to execute when state transitions to insufficient-data." msgstr "" #: heat/engine/resources/cloud_watch.py:107 #: heat/engine/resources/ceilometer/alarm.py:140 msgid "Threshold to evaluate against." msgstr "" #: heat/engine/resources/cloud_watch.py:112 msgid "Unit for the metric." msgstr "" #: heat/engine/resources/eip.py:38 msgid "Set to \"vpc\" to have IP address allocation associated to your VPC." msgstr "" #: heat/engine/resources/eip.py:46 msgid "Instance ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:51 msgid "" "ID that AWS assigns to represent the allocation of the address for use " "with Amazon VPC. Returned only for VPC elastic IP addresses." msgstr "" #: heat/engine/resources/eip.py:68 heat/engine/resources/eip.py:75 #, python-format msgid "Floating IPs not found: %s" msgstr "" #: heat/engine/resources/eip.py:92 heat/engine/resources/eip.py:109 #, python-format msgid "ElasticIp create %s" msgstr "" #: heat/engine/resources/eip.py:95 #, python-format msgid "Domain property can not be set on resource %s without Neutron available" msgstr "" #: heat/engine/resources/eip.py:102 msgid "" "No default floating IP pool configured. Set 'default_floating_pool' in " "nova.conf." msgstr "" #: heat/engine/resources/eip.py:159 msgid "Instance ID to associate with EIP specified by EIP property." msgstr "" #: heat/engine/resources/eip.py:163 msgid "EIP address to associate with instance." msgstr "" #: heat/engine/resources/eip.py:167 msgid "Allocation ID for VPC EIP address." msgstr "" #: heat/engine/resources/eip.py:171 msgid "Network interface ID to associate with EIP." msgstr "" #: heat/engine/resources/eip.py:188 msgid "Skipping association, InstanceId not specified" msgstr "" #: heat/engine/resources/eip.py:194 #, python-format msgid "ElasticIpAssociation %(instance)s.add_floating_ip(%(eip)s)" msgstr "" #: heat/engine/resources/eip.py:211 msgid "Skipping association, resource not specified" msgstr "" #: heat/engine/resources/instance.py:46 msgid "Instance ID to be restarted." msgstr "" #: heat/engine/resources/instance.py:52 msgid "A signed url to handle the alarm (Heat extension)." msgstr "" #: heat/engine/resources/instance.py:88 #, python-format msgid "%(name)s Alarm, can not find instance %(instance)s" msgstr "" #: heat/engine/resources/instance.py:94 #, python-format msgid "%(name)s Alarm, restarting resource: %(victim)s" msgstr "" #: heat/engine/resources/instance.py:169 msgid "Availability zone to launch the instance in." msgstr "" #: heat/engine/resources/instance.py:207 msgid "Security group IDs to assign." msgstr "" #: heat/engine/resources/instance.py:211 msgid "Network interfaces to associate with instance." msgstr "" #: heat/engine/resources/instance.py:220 msgid "Subnet ID to launch instance in." msgstr "" #: heat/engine/resources/instance.py:224 msgid "Tags to attach to instance." msgstr "" #: heat/engine/resources/instance.py:271 msgid "Volumes to attach to instance." msgstr "" #: heat/engine/resources/instance.py:278 heat/engine/resources/volume.py:318 msgid "" "The device where the volume is exposed on the instance. This assignment " "may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/instance.py:287 heat/engine/resources/volume.py:313 #: heat/engine/resources/volume.py:490 msgid "The ID of the volume to be attached." msgstr "" #: heat/engine/resources/instance.py:295 msgid "The Availability Zone where the specified instance is launched." msgstr "" #: heat/engine/resources/instance.py:298 msgid "Private DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:300 msgid "Public DNS name of the specified instance." msgstr "" #: heat/engine/resources/instance.py:302 msgid "Private IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:304 msgid "Public IP address of the specified instance." msgstr "" #: heat/engine/resources/instance.py:345 #, python-format msgid "%(name)s._resolve_attribute(%(attname)s) == %(res)s" msgstr "" #: heat/engine/resources/instance.py:503 #, python-format msgid "Creation of server %(server)s failed: %(message)s (%(code)s)" msgstr "" #: heat/engine/resources/instance.py:510 heat/engine/resources/server.py:559 #, python-format msgid "Creation of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/instance.py:590 #, python-format msgid "Deletion of server %s failed." msgstr "" #: heat/engine/resources/instance.py:638 heat/engine/resources/server.py:951 #, python-format msgid "Cannot suspend %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:644 heat/engine/resources/instance.py:700 #, python-format msgid "Failed to find instance %s" msgstr "" #: heat/engine/resources/instance.py:647 #, python-format msgid "suspending instance %s" msgstr "" #: heat/engine/resources/instance.py:669 heat/engine/resources/server.py:977 #, python-format msgid "%(name)s check_suspend_complete status = %(status)s" msgstr "" #: heat/engine/resources/instance.py:677 #, python-format msgid " nova reported unexpected instance[%(instance)s] status[%(status)s]" msgstr "" #: heat/engine/resources/instance.py:694 heat/engine/resources/server.py:997 #, python-format msgid "Cannot resume %s, resource_id not set" msgstr "" #: heat/engine/resources/instance.py:703 #, python-format msgid "resuming instance %s" msgstr "" #: heat/engine/resources/internet_gateway.py:75 #, python-format msgid "Expected 1 external network, found %d" msgstr "" #: heat/engine/resources/internet_gateway.py:91 msgid "VPC ID for this gateway association." msgstr "" #: heat/engine/resources/internet_gateway.py:96 msgid "ID of the InternetGateway." msgstr "" #: heat/engine/resources/internet_gateway.py:100 msgid "ID of the VPNGateway to attach to the VPC." msgstr "" #: heat/engine/resources/loadbalancer.py:239 msgid "The Availability Zones in which to create the load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:244 msgid "An application health check for the instances." msgstr "" #: heat/engine/resources/loadbalancer.py:248 msgid "" "The number of consecutive health probe successes required before moving " "the instance to the healthy state." msgstr "" #: heat/engine/resources/loadbalancer.py:255 msgid "" "The approximate interval, in seconds, between health checks of an " "individual instance." msgstr "" #: heat/engine/resources/loadbalancer.py:261 msgid "The port being checked." msgstr "" #: heat/engine/resources/loadbalancer.py:266 msgid "Health probe timeout, in seconds." msgstr "" #: heat/engine/resources/loadbalancer.py:271 msgid "" "The number of consecutive health probe failures required before moving " "the instance to the unhealthy state" msgstr "" #: heat/engine/resources/loadbalancer.py:280 msgid "The list of instance IDs load balanced." msgstr "" #: heat/engine/resources/loadbalancer.py:285 msgid "One or more listeners for this load balancer." msgstr "" #: heat/engine/resources/loadbalancer.py:291 msgid "TCP port on which the instance server is listening." msgstr "" #: heat/engine/resources/loadbalancer.py:297 msgid "The external load balancer port number." msgstr "" #: heat/engine/resources/loadbalancer.py:302 msgid "The load balancer transport protocol to use." msgstr "" #: heat/engine/resources/loadbalancer.py:345 msgid "The name of the hosted zone that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:347 msgid "The ID of the hosted zone name that is associated with the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:350 msgid "The DNS name for the LoadBalancer." msgstr "" #: heat/engine/resources/loadbalancer.py:351 msgid "" "The security group that you can use as part of your inbound rules for " "your LoadBalancer's back-end instances." msgstr "" #: heat/engine/resources/loadbalancer.py:355 msgid "Owner of the source security group." msgstr "" #: heat/engine/resources/loadbalancer.py:417 #, python-format msgid "haproxy server:%s" msgstr "" #: heat/engine/resources/loadbalancer.py:428 #, python-format msgid "Using custom loadbalancer template %s" msgstr "" #: heat/engine/resources/loadbalancer.py:497 msgid "Custom LoadBalancer template can not be found" msgstr "" #: heat/engine/resources/network_interface.py:43 msgid "Description for this interface." msgstr "" #: heat/engine/resources/network_interface.py:47 msgid "List of security group IDs associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:55 msgid "Flag indicating if traffic to or from instance is validated." msgstr "" #: heat/engine/resources/network_interface.py:60 msgid "Subnet ID to associate with this interface." msgstr "" #: heat/engine/resources/network_interface.py:67 msgid "List of tags associated with this interface." msgstr "" #: heat/engine/resources/network_interface.py:83 msgid "Private IP address of the network interface." msgstr "" #: heat/engine/resources/nova_floatingip.py:29 msgid "Allocate a floating IP from a given floating IP pool." msgstr "" #: heat/engine/resources/nova_floatingip.py:35 msgid "Pool from which floating IP is allocated." msgstr "" #: heat/engine/resources/nova_floatingip.py:36 msgid "Allocated floating IP address." msgstr "" #: heat/engine/resources/nova_floatingip.py:56 msgid "" "Could not allocate floating IP. Probably there is no default floating IP " "pool is configured." msgstr "" #: heat/engine/resources/nova_floatingip.py:89 msgid "Server to assign floating IP to." msgstr "" #: heat/engine/resources/nova_floatingip.py:94 msgid "ID of the floating IP to assign to the server." msgstr "" #: heat/engine/resources/nova_keypair.py:50 msgid "The name of the key pair." msgstr "" #: heat/engine/resources/nova_keypair.py:55 msgid "" "True if the system should remember a generated private key; False " "otherwise." msgstr "" #: heat/engine/resources/nova_keypair.py:61 msgid "" "The optional public key. This allows users to supply the public key from " "a pre-existing key pair. If not supplied, a new key pair will be " "generated." msgstr "" #: heat/engine/resources/nova_keypair.py:68 msgid "The public key." msgstr "" #: heat/engine/resources/nova_keypair.py:69 msgid "The private key if it has been saved." msgstr "" #: heat/engine/resources/nova_utils.py:57 #, python-format msgid "" "Server %(name)s (%(id)s) received an OverLimit response during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:64 #, python-format msgid "" "Server \"%(name)s\" (%(id)s) received the following exception during " "server.get(): %(exception)s" msgstr "" #: heat/engine/resources/nova_utils.py:86 #: heat/engine/resources/nova_utils.py:100 #, python-format msgid "Image %s was not found in glance" msgstr "" #: heat/engine/resources/nova_utils.py:94 #, python-format msgid "Error retrieving image list from nova: %s" msgstr "" #: heat/engine/resources/nova_utils.py:104 #, python-format msgid "Multiple images %s were found in glance with name" msgstr "" #: heat/engine/resources/nova_utils.py:319 #, python-format msgid "Resizing to '%(flavor)s' failed, status '%(status)s'" msgstr "" #: heat/engine/resources/nova_utils.py:341 #, python-format msgid "Rebuilding server failed, status '%s'" msgstr "" #: heat/engine/resources/nova_utils.py:373 heat/engine/resources/server.py:624 #, python-format msgid "Instance (%(server)s) not found: %(ex)s" msgstr "" #: heat/engine/resources/os_database.py:55 msgid "Name of the DB instance to create." msgstr "" #: heat/engine/resources/os_database.py:63 msgid "Reference to a flavor for creating DB instance." msgstr "" #: heat/engine/resources/os_database.py:68 msgid "Database volume size in GB." msgstr "" #: heat/engine/resources/os_database.py:76 msgid "List of databases to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:83 msgid "Set of symbols and encodings." msgstr "" #: heat/engine/resources/os_database.py:88 msgid "Set of rules for comparing characters in a character set." msgstr "" #: heat/engine/resources/os_database.py:94 msgid "Specifies database names for creating databases on instance creation." msgstr "" #: heat/engine/resources/os_database.py:109 msgid "List of users to be created on DB instance creation." msgstr "" #: heat/engine/resources/os_database.py:116 msgid "User name to create a user on instance creation." msgstr "" #: heat/engine/resources/os_database.py:128 msgid "Password for those users on instance creation." msgstr "" #: heat/engine/resources/os_database.py:139 msgid "The host from which a user is allowed to connect to the database." msgstr "" #: heat/engine/resources/os_database.py:145 msgid "Names of databases that those users can access on instance creation." msgstr "" #: heat/engine/resources/os_database.py:157 msgid "Name of the availability zone for DB instance." msgstr "" #: heat/engine/resources/os_database.py:161 msgid "DB instance restore point." msgstr "" #: heat/engine/resources/os_database.py:166 msgid "Hostname of the instance" msgstr "" #: heat/engine/resources/os_database.py:167 msgid "Api endpoint reference of the instance" msgstr "" #: heat/engine/resources/os_database.py:226 #, python-format msgid "" "Stack %(name)s (%(id)s) received an OverLimit response during " "instance.get(): %(exception)s" msgstr "" #: heat/engine/resources/os_database.py:239 msgid "Database instance creation failed." msgstr "" #: heat/engine/resources/os_database.py:244 #, python-format msgid "" "Database instance %(database)s created (flavor:%(flavor)s, " "volume:%(volume)s)" msgstr "" #: heat/engine/resources/os_database.py:262 #, python-format msgid "Database instance %s not found." msgstr "" #: heat/engine/resources/os_database.py:299 msgid "Databases property is required if users property is provided" msgstr "" #: heat/engine/resources/os_database.py:306 #, python-format msgid "Must provide access to at least one database for user %s" msgstr "" #: heat/engine/resources/os_database.py:314 #, python-format msgid "Database %s specified for user does not exist in databases." msgstr "" #: heat/engine/resources/random_string.py:41 msgid "Length of the string to generate." msgstr "" #: heat/engine/resources/random_string.py:49 msgid "Sequence of characters to build the random string from." msgstr "" #: heat/engine/resources/random_string.py:60 msgid "" "Value which can be set or changed on stack update to trigger the resource" " for replacement with a new random string . The salt value itself is " "ignored by the random generator." msgstr "" #: heat/engine/resources/random_string.py:67 msgid "" "The random string generated by this resource. This value is also " "available by referencing the resource." msgstr "" #: heat/engine/resources/resource_group.py:61 msgid "The number of instances to create." msgstr "" #: heat/engine/resources/resource_group.py:70 msgid "" "Resource definition for the resources in the group. The value of this " "property is the definition of a resource just as if it had been declared " "in the template itself." msgstr "" #: heat/engine/resources/resource_group.py:76 msgid "The type of the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:81 msgid "Property values for the resources in the group" msgstr "" #: heat/engine/resources/resource_group.py:89 msgid "A list of resource IDs for the resources in the group" msgstr "" #: heat/engine/resources/route_table.py:45 msgid "VPC ID for where the route table is created." msgstr "" #: heat/engine/resources/route_table.py:52 msgid "List of tags to be attached to this resource." msgstr "" #: heat/engine/resources/route_table.py:121 msgid "Route table ID." msgstr "" #: heat/engine/resources/route_table.py:126 msgid "Subnet ID." msgstr "" #: heat/engine/resources/s3.py:50 msgid "" "A predefined access control list (ACL) that grants permissions on the " "bucket." msgstr "" #: heat/engine/resources/s3.py:62 msgid "Information used to configure the bucket as a static website." msgstr "" #: heat/engine/resources/s3.py:66 msgid "The name of the index document." msgstr "" #: heat/engine/resources/s3.py:70 msgid "The name of the error document." msgstr "" #: heat/engine/resources/s3.py:76 msgid "Tags to attach to the bucket." msgstr "" #: heat/engine/resources/s3.py:82 msgid "The tag key name." msgstr "" #: heat/engine/resources/s3.py:87 msgid "The tag value." msgstr "" #: heat/engine/resources/s3.py:96 msgid "The DNS name of the specified bucket." msgstr "" #: heat/engine/resources/s3.py:97 msgid "The website endpoint for the specified bucket." msgstr "" #: heat/engine/resources/s3.py:111 #, python-format msgid "S3Bucket create container %(container)s with headers %(headers)s" msgstr "" #: heat/engine/resources/s3.py:143 #, python-format msgid "S3Bucket delete container %s" msgstr "" #: heat/engine/resources/s3.py:148 heat/engine/resources/swift.py:130 #, python-format msgid "Delete container failed: %s" msgstr "" #: heat/engine/resources/security_group.py:71 #: heat/engine/resources/neutron/security_group.py:118 msgid "Description of the security group." msgstr "" #: heat/engine/resources/security_group.py:76 msgid "Physical ID of the VPC." msgstr "" #: heat/engine/resources/security_group.py:82 msgid "List of security group ingress rules." msgstr "" #: heat/engine/resources/security_group.py:90 msgid "List of security group egress rules." msgstr "" #: heat/engine/resources/security_group.py:285 #, python-format msgid "Security Group \"%(group_name)s\" not found" msgstr "" #: heat/engine/resources/server.py:89 msgid "Server name." msgstr "" #: heat/engine/resources/server.py:94 msgid "The ID or name of the image to boot with." msgstr "" #: heat/engine/resources/server.py:102 msgid "Block device mappings for this server." msgstr "" #: heat/engine/resources/server.py:108 msgid "" "A device name where the volume will be attached in the system at " "/dev/device_name. This value is typically vda." msgstr "" #: heat/engine/resources/server.py:115 msgid "" "The ID of the volume to boot from. Only one of volume_id or snapshot_id " "should be provided." msgstr "" #: heat/engine/resources/server.py:121 msgid "The ID of the snapshot to create a volume from." msgstr "" #: heat/engine/resources/server.py:126 msgid "" "The size of the volume, in GB. It is safe to leave this blank and have " "the Compute service infer the size." msgstr "" #: heat/engine/resources/server.py:132 msgid "" "Indicate whether the volume should be deleted when the server is " "terminated." msgstr "" #: heat/engine/resources/server.py:140 msgid "The ID or name of the flavor to boot onto." msgstr "" #: heat/engine/resources/server.py:146 msgid "" "Policy on how to apply a flavor update; either by requesting a server " "resize or by replacing the entire server." msgstr "" #: heat/engine/resources/server.py:156 msgid "" "Policy on how to apply an image-id update; either by requesting a server " "rebuild or by replacing the entire server" msgstr "" #: heat/engine/resources/server.py:167 msgid "Name of keypair to inject into the server." msgstr "" #: heat/engine/resources/server.py:174 msgid "" "Name of the administrative user to use on the server. This property will " "be removed from Juno in favor of the default cloud-init user set up for " "each image (e.g. \"ubuntu\" for Ubuntu 12.04+, \"fedora\" for Fedora 19+ " "and \"cloud-user\" for CentOS/RHEL 6.5)." msgstr "" #: heat/engine/resources/server.py:183 msgid "Name of the availability zone for server placement." msgstr "" #: heat/engine/resources/server.py:187 msgid "" "List of security group names or IDs. Cannot be used if neutron ports are " "associated with this server; assign security groups to the ports instead." msgstr "" #: heat/engine/resources/server.py:194 msgid "" "An ordered list of nics to be added to this server, with information " "about connected networks, fixed ips, port etc." msgstr "" #: heat/engine/resources/server.py:201 msgid "ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:204 heat/engine/resources/volume.py:406 #, python-format msgid "Use property %s." msgstr "" #: heat/engine/resources/server.py:208 msgid "Name or ID of network to create a port on." msgstr "" #: heat/engine/resources/server.py:212 msgid "Fixed IP address to specify for the port created on the requested network." msgstr "" #: heat/engine/resources/server.py:217 msgid "ID of an existing port to associate with this server." msgstr "" #: heat/engine/resources/server.py:226 msgid "Arbitrary key-value pairs specified by the client to help boot a server." msgstr "" #: heat/engine/resources/server.py:231 msgid "" "Arbitrary key/value metadata to store for this server. Both keys and " "values must be 255 characters or less. Non-string values will be " "serialized to JSON (and the serialized string must be 255 characters or " "less)." msgstr "" #: heat/engine/resources/server.py:239 msgid "" "How the user_data should be formatted for the server. For HEAT_CFNTOOLS, " "the user_data is bundled as part of the heat-cfntools cloud-init boot " "configuration data. For RAW the user_data is passed to Nova unmodified. " "For SOFTWARE_CONFIG user_data is bundled as part of the software config " "data, and metadata is derived from any associated SoftwareDeployment " "resources." msgstr "" #: heat/engine/resources/server.py:253 msgid "" "How the server should receive the metadata required for software " "configuration. POLL_SERVER_CFN will allow calls to the cfn API action " "DescribeStackResource authenticated with the provided keypair. " "POLL_SERVER_HEAT will allow calls to the Heat API resource-show using the" " provided keystone credentials." msgstr "" #: heat/engine/resources/server.py:266 msgid "User data script to be executed by cloud-init." msgstr "" #: heat/engine/resources/server.py:271 msgid "A UUID for the set of servers being requested." msgstr "" #: heat/engine/resources/server.py:275 msgid "value for config drive either boolean, or volume-id." msgstr "" #: heat/engine/resources/server.py:279 msgid "Control how the disk is partitioned when the server is created." msgstr "" #: heat/engine/resources/server.py:287 msgid "" "A map of files to create/overwrite on the server upon boot. Keys are file" " names and values are the file contents." msgstr "" #: heat/engine/resources/server.py:293 msgid "The administrator password for the server." msgstr "" #: heat/engine/resources/server.py:300 msgid "A dict of all server details as returned by the API." msgstr "" #: heat/engine/resources/server.py:301 msgid "A dict of all network addresses as returned by the API." msgstr "" #: heat/engine/resources/server.py:303 msgid "" "A dict of assigned network addresses of the form: {\"public\": [ip1, " "ip2...], \"private\": [ip3, ip4]}." msgstr "" #: heat/engine/resources/server.py:305 msgid "" "Convenience attribute to fetch the first assigned network address, or an " "empty string if nothing has been assigned at this time. Result may not be" " predictable if the server has addresses from more than one network." msgstr "" #: heat/engine/resources/server.py:311 msgid "AWS compatible instance name." msgstr "" #: heat/engine/resources/server.py:312 msgid "The manually assigned alternative public IPv4 address of the server." msgstr "" #: heat/engine/resources/server.py:314 msgid "The manually assigned alternative public IPv6 address of the server." msgstr "" #: heat/engine/resources/server.py:555 #, python-format msgid "Creation of server %s failed." msgstr "" #: heat/engine/resources/server.py:845 #, python-format msgid "Either volume_id or snapshot_id must be specified for device mapping %s" msgstr "" #: heat/engine/resources/server.py:852 #, python-format msgid "Neither image nor bootable volume is specified for instance %s" msgstr "" #: heat/engine/resources/server.py:865 #, python-format msgid "" "Properties \"%(uuid)s\" and \"%(id)s\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"%(uuid)s\" property " "is deprecated. Use only \"%(id)s\" property." msgstr "" #: heat/engine/resources/server.py:875 #, python-format msgid "" "For the server \"%(server)s\" the \"%(uuid)s\" property is set to network" " \"%(network)s\". \"%(uuid)s\" property is deprecated. Use \"%(id)s\" " "property instead." msgstr "" #: heat/engine/resources/server.py:902 #, python-format msgid "" "Instance metadata must not contain greater than %s entries. This is the " "maximum number allowed by your service provider" msgstr "" #: heat/engine/resources/server.py:911 #, python-format msgid "The personality property may not contain greater than %s entries." msgstr "" #: heat/engine/resources/server.py:917 #, python-format msgid "" "The contents of personality file \"%(path)s\" is larger than the maximum " "allowed personality file size (%(max_size)s bytes)." msgstr "" #: heat/engine/resources/server.py:957 heat/engine/resources/server.py:1003 #, python-format msgid "Failed to find server %s" msgstr "" #: heat/engine/resources/server.py:960 #, python-format msgid "suspending server %s" msgstr "" #: heat/engine/resources/server.py:984 #, python-format msgid "Suspend of server %(server)s failed with unknown status: %(status)s" msgstr "" #: heat/engine/resources/server.py:1006 #, python-format msgid "resuming server %s" msgstr "" #: heat/engine/resources/stack.py:42 msgid "" "The URL of a template that specifies the stack to be created as a " "resource." msgstr "" #: heat/engine/resources/stack.py:49 msgid "The length of time, in minutes, to wait for the nested stack creation." msgstr "" #: heat/engine/resources/stack.py:55 msgid "The set of parameters passed to this nested stack." msgstr "" #: heat/engine/resources/stack.py:66 heat/engine/resources/stack.py:112 #, python-format msgid "Could not fetch remote template '%(url)s': %(exc)s" msgstr "" #: heat/engine/resources/subnet.py:42 msgid "Availability zone in which you want the subnet." msgstr "" #: heat/engine/resources/subnet.py:46 msgid "CIDR block to apply to subnet." msgstr "" #: heat/engine/resources/subnet.py:51 msgid "" "Ref structure that contains the ID of the VPC on which you want to create" " the subnet." msgstr "" #: heat/engine/resources/subnet.py:59 msgid "List of tags to attach to this resource." msgstr "" #: heat/engine/resources/swift.py:37 msgid "Name for the container. If not specified, a unique name will be generated." msgstr "" #: heat/engine/resources/swift.py:42 msgid "Specify the ACL permissions on who can read objects in the container." msgstr "" #: heat/engine/resources/swift.py:47 msgid "Specify the ACL permissions on who can write objects to the container." msgstr "" #: heat/engine/resources/swift.py:52 msgid "" "A map of user-defined meta data to associate with the container. Each key" " in the map will set the header X-Container-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:59 msgid "" "A map of user-defined meta data to associate with the account. Each key " "in the map will set the header X-Account-Meta-{key} with the " "corresponding value." msgstr "" #: heat/engine/resources/swift.py:67 msgid "The host from the container URL." msgstr "" #: heat/engine/resources/swift.py:68 msgid "The URL of the container." msgstr "" #: heat/engine/resources/swift.py:69 msgid "The parent URL of the container." msgstr "" #: heat/engine/resources/swift.py:70 msgid "The number of objects stored in the container." msgstr "" #: heat/engine/resources/swift.py:71 msgid "The number of bytes stored in the container." msgstr "" #: heat/engine/resources/swift.py:72 msgid "A map containing all headers for the container." msgstr "" #: heat/engine/resources/swift.py:108 #, python-format msgid "" "SwiftContainer create container %(container)s with container headers " "%(container_headers)s and account headers %(account_headers)s" msgstr "" #: heat/engine/resources/swift.py:124 #, python-format msgid "SwiftContainer delete container %s" msgstr "" #: heat/engine/resources/swift.py:149 #, python-format msgid "Head container failed: %s" msgstr "" #: heat/engine/resources/template_resource.py:68 msgid "Only Templates with an extension of .yaml or .template are supported" msgstr "" #: heat/engine/resources/template_resource.py:165 #, python-format msgid "Could not fetch remote template '%(name)s': %(exc)s" msgstr "" #: heat/engine/resources/template_resource.py:178 #, python-format msgid "Unknown error retrieving %s" msgstr "" #: heat/engine/resources/template_resource.py:187 #, python-format msgid "Required property %(n)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:195 #, python-format msgid "" "Property %(n)s type mismatch between facade %(type)s (%(fs_type)s) and " "provider (%(ps_type)s)" msgstr "" #: heat/engine/resources/template_resource.py:204 #, python-format msgid "Provider requires property %(n)s unknown in facade %(type)s" msgstr "" #: heat/engine/resources/template_resource.py:211 #, python-format msgid "Attribute %(attr)s for facade %(type)s missing in provider" msgstr "" #: heat/engine/resources/template_resource.py:224 #, python-format msgid "Failed to retrieve template data: %s" msgstr "" #: heat/engine/resources/user.py:56 msgid "A login profile for the user." msgstr "" #: heat/engine/resources/user.py:65 msgid "Access policies to apply to the user." msgstr "" #: heat/engine/resources/user.py:80 heat/engine/resources/user.py:120 #, python-format msgid "Ignoring policy %s, must be string resource name" msgstr "" #: heat/engine/resources/user.py:87 #, python-format msgid "Policy %(policy)s does not exist in stack %(stack)s" msgstr "" #: heat/engine/resources/user.py:94 #, python-format msgid "Policy %s is not an AccessPolicy resource" msgstr "" #: heat/engine/resources/user.py:144 msgid "The name of the user that the new key will belong to." msgstr "" #: heat/engine/resources/user.py:158 msgid "Username associated with the AccessKey." msgstr "" #: heat/engine/resources/user.py:159 msgid "Keypair secret key." msgstr "" #: heat/engine/resources/user.py:185 #, python-format msgid "could not find user %s" msgstr "" #: heat/engine/resources/user.py:205 #, python-format msgid "Error deleting %s - user not found" msgstr "" #: heat/engine/resources/user.py:215 heat/engine/resources/user.py:239 #, python-format msgid "could not get secret for %(username)s Error:%(msg)s" msgstr "" #: heat/engine/resources/user.py:270 msgid "" "Resources that users are allowed to access by the DescribeStackResource " "API." msgstr "" #: heat/engine/resources/user.py:287 #, python-format msgid "AccessPolicy resource %s not in stack" msgstr "" #: heat/engine/resources/volume.py:50 heat/engine/resources/volume.py:367 msgid "The availability zone in which the volume will be created." msgstr "" #: heat/engine/resources/volume.py:55 heat/engine/resources/volume.py:371 #: heat/engine/resources/volume.py:425 msgid "The size of the volume in GB." msgstr "" #: heat/engine/resources/volume.py:59 msgid "If specified, the backup used as the source to create the volume." msgstr "" #: heat/engine/resources/volume.py:64 msgid "The list of tags to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:108 msgid "Backups not supported." msgstr "" #: heat/engine/resources/volume.py:153 msgid "can not delete volume when in-use" msgstr "" #: heat/engine/resources/volume.py:154 msgid "Volume in use" msgstr "" #: heat/engine/resources/volume.py:221 #, python-format msgid "%(name)s - volume status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:229 #, python-format msgid "%s - complete" msgstr "" #: heat/engine/resources/volume.py:262 heat/engine/resources/volume.py:295 #, python-format msgid "%s - volume not found" msgstr "" #: heat/engine/resources/volume.py:278 #, python-format msgid "%s - volume still in use" msgstr "" #: heat/engine/resources/volume.py:289 #, python-format msgid "%(name)s - status: %(status)s" msgstr "" #: heat/engine/resources/volume.py:308 msgid "The ID of the instance to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:378 msgid "If specified, the snapshot to create the volume from." msgstr "" #: heat/engine/resources/volume.py:382 msgid "If specified, the backup to create the volume from." msgstr "" #: heat/engine/resources/volume.py:386 msgid "A name used to distinguish the volume." msgstr "" #: heat/engine/resources/volume.py:390 msgid "A description of the volume." msgstr "" #: heat/engine/resources/volume.py:394 msgid "If specified, the type of volume to use, mapping to a specific backend." msgstr "" #: heat/engine/resources/volume.py:399 msgid "Key/value pairs to associate with the volume." msgstr "" #: heat/engine/resources/volume.py:403 msgid "The ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:410 msgid "If specified, the name or ID of the image to create the volume from." msgstr "" #: heat/engine/resources/volume.py:418 msgid "If specified, the volume to use as source." msgstr "" #: heat/engine/resources/volume.py:423 msgid "The availability zone in which the volume is located." msgstr "" #: heat/engine/resources/volume.py:426 msgid "The snapshot the volume was created from, if any." msgstr "" #: heat/engine/resources/volume.py:427 msgid "Name of the volume." msgstr "" #: heat/engine/resources/volume.py:428 msgid "Description of the volume." msgstr "" #: heat/engine/resources/volume.py:429 msgid "The type of the volume mapping to a backend, if any." msgstr "" #: heat/engine/resources/volume.py:431 msgid "Key/value pairs associated with the volume." msgstr "" #: heat/engine/resources/volume.py:432 msgid "The volume used as source, if any." msgstr "" #: heat/engine/resources/volume.py:433 msgid "The current status of the volume." msgstr "" #: heat/engine/resources/volume.py:434 msgid "The timestamp indicating volume creation." msgstr "" #: heat/engine/resources/volume.py:435 msgid "Boolean indicating if the volume can be booted or not." msgstr "" #: heat/engine/resources/volume.py:485 msgid "The ID of the server to which the volume attaches." msgstr "" #: heat/engine/resources/volume.py:495 msgid "" "The location where the volume is exposed on the instance. This assignment" " may not be honored and it is advised that the path /dev/disk/by-" "id/virtio- be used instead." msgstr "" #: heat/engine/resources/vpc.py:43 msgid "CIDR block to apply to the VPC." msgstr "" #: heat/engine/resources/vpc.py:47 msgid "" "Allowed tenancy of instances launched in the VPC. default - any tenancy; " "dedicated - instance will be dedicated, regardless of the tenancy option " "specified at instance launch." msgstr "" #: heat/engine/resources/vpc.py:61 msgid "List of tags to attach to the instance." msgstr "" #: heat/engine/resources/vpc.py:104 #, python-format msgid "Multiple routers found with name %s" msgstr "" #: heat/engine/resources/wait_condition.py:77 #, python-format msgid "Overwriting Metadata item for UniqueId %s!" msgstr "" #: heat/engine/resources/wait_condition.py:87 #, python-format msgid "Metadata failed validation for %s" msgstr "" #: heat/engine/resources/wait_condition.py:88 msgid "Metadata format invalid" msgstr "" #: heat/engine/resources/wait_condition.py:143 #, python-format msgid "%(len)d of %(count)d received - %(reasons)s" msgstr "" #: heat/engine/resources/wait_condition.py:145 #, python-format msgid "%(len)d of %(count)d received" msgstr "" #: heat/engine/resources/wait_condition.py:159 msgid "" "A reference to the wait condition handle used to signal this wait " "condition." msgstr "" #: heat/engine/resources/wait_condition.py:165 msgid "The number of seconds to wait for the correct number of signals to arrive." msgstr "" #: heat/engine/resources/wait_condition.py:174 msgid "" "The number of success signals that must be received before the stack " "creation process continues." msgstr "" #: heat/engine/resources/wait_condition.py:185 msgid "" "JSON serialized dict containing data associated with wait condition " "signals sent to the handle." msgstr "" #: heat/engine/resources/wait_condition.py:198 #, python-format msgid "WaitCondition invalid Handle tenant %s" msgstr "" #: heat/engine/resources/wait_condition.py:201 #: heat/engine/resources/wait_condition.py:204 #, python-format msgid "WaitCondition invalid Handle stack %s" msgstr "" #: heat/engine/resources/wait_condition.py:207 #: heat/engine/resources/wait_condition.py:211 #, python-format msgid "WaitCondition invalid Handle %s" msgstr "" #: heat/engine/resources/wait_condition.py:225 #, python-format msgid "%(name)s Timed out (%(timeout)s)" msgstr "" #: heat/engine/resources/wait_condition.py:233 #, python-format msgid "%(name)s Failed (%(failure)s)" msgstr "" #: heat/engine/resources/wait_condition.py:238 #, python-format msgid "%s Succeeded" msgstr "" #: heat/engine/resources/wait_condition.py:285 #, python-format msgid "%(name)s.GetAtt(%(key)s) == %(res)s" msgstr "" #: heat/engine/resources/ceilometer/alarm.py:39 msgid "True if alarm evaluation/actioning is enabled." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:45 msgid "A list of URLs (webhooks) to invoke when state transitions to alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:51 msgid "A list of URLs (webhooks) to invoke when state transitions to ok." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:57 msgid "" "A list of URLs (webhooks) to invoke when state transitions to " "insufficient-data." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:63 msgid "" "False to trigger actions when the threshold is reached AND the alarm's " "state has changed. By default, actions are called each time the threshold" " is reached." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:107 msgid "Operator used to compare specified statistic with threshold." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:121 msgid "Meter name watched by the alarm." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:131 msgid "Meter statistic to evaluate." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:146 msgid "" "Meter should match this resource metadata (key=value) additionally to the" " meter_name." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:212 msgid "List of alarm identifiers to combine." msgstr "" #: heat/engine/resources/ceilometer/alarm.py:218 msgid "Operator used to combine the alarms." msgstr "" #: heat/engine/resources/neutron/firewall.py:40 #: heat/engine/resources/neutron/firewall.py:66 msgid "Name for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:45 msgid "Description for the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:50 msgid "" "Administrative state of the firewall. If false (down), firewall does not " "forward packets and will drop all traffic to/from VMs behind the " "firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:58 msgid "The ID of the firewall policy that this firewall is associated with." msgstr "" #: heat/engine/resources/neutron/firewall.py:67 msgid "Description of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:68 msgid "The administrative state of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:69 msgid "Unique identifier of the firewall policy used to create the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:71 msgid "The status of the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:72 #: heat/engine/resources/neutron/firewall.py:292 msgid "Id of the tenant owning the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:73 #: heat/engine/resources/neutron/floatingip.py:68 #: heat/engine/resources/neutron/loadbalancer.py:118 #: heat/engine/resources/neutron/loadbalancer.py:496 #: heat/engine/resources/neutron/net.py:87 #: heat/engine/resources/neutron/network_gateway.py:122 #: heat/engine/resources/neutron/port.py:150 #: heat/engine/resources/neutron/provider_net.py:68 #: heat/engine/resources/neutron/router.py:98 #: heat/engine/resources/neutron/subnet.py:150 #: heat/engine/resources/neutron/vpnservice.py:80 msgid "All attributes." msgstr "" #: heat/engine/resources/neutron/firewall.py:118 #: heat/engine/resources/neutron/firewall.py:151 msgid "Name for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:123 msgid "Description for the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:128 msgid "Whether this policy should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:134 msgid "" "Whether this policy should be audited. When set to True, each time the " "firewall policy or the associated firewall rules are changed, this " "attribute will be set to False and will have to be explicitly set to True" " through an update operation." msgstr "" #: heat/engine/resources/neutron/firewall.py:144 msgid "An ordered list of firewall rules to apply to the firewall." msgstr "" #: heat/engine/resources/neutron/firewall.py:152 msgid "Description of the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:153 msgid "List of firewall rules in this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:154 msgid "Shared status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:155 msgid "Audit status of this firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:156 msgid "Id of the tenant owning the firewall policy." msgstr "" #: heat/engine/resources/neutron/firewall.py:206 #: heat/engine/resources/neutron/firewall.py:275 msgid "Name for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:211 msgid "Description for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:216 msgid "Whether this rule should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/firewall.py:222 msgid "Protocol for the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:230 msgid "Internet protocol version." msgstr "" #: heat/engine/resources/neutron/firewall.py:239 msgid "Source IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:244 msgid "Destination IP address or CIDR." msgstr "" #: heat/engine/resources/neutron/firewall.py:249 msgid "Source port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:254 msgid "Destination port number or a range." msgstr "" #: heat/engine/resources/neutron/firewall.py:259 msgid "Action to be performed on the traffic matching the rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:268 msgid "Whether this rule should be enabled." msgstr "" #: heat/engine/resources/neutron/firewall.py:276 msgid "Description of the firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:277 msgid "" "Unique identifier of the firewall policy to which this firewall rule " "belongs." msgstr "" #: heat/engine/resources/neutron/firewall.py:279 msgid "Shared status of this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:280 msgid "Protocol value for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:281 msgid "Ip_version for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:282 msgid "Source ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:283 msgid "Destination ip_address for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:285 msgid "Source port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:286 msgid "Destination port range for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:288 msgid "Allow or deny action for this firewall rule." msgstr "" #: heat/engine/resources/neutron/firewall.py:289 msgid "Indicates whether this firewall rule is enabled or not." msgstr "" #: heat/engine/resources/neutron/firewall.py:291 msgid "Position of the rule within the firewall policy." msgstr "" #: heat/engine/resources/neutron/floatingip.py:37 msgid "ID of network to allocate floating IP from." msgstr "" #: heat/engine/resources/neutron/floatingip.py:42 msgid "" "Extra parameters to include in the \"floatingip\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/floatingip.py:49 #: heat/engine/resources/neutron/floatingip.py:115 msgid "" "ID of an existing port with at least one IP address to associate with " "this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:54 #: heat/engine/resources/neutron/floatingip.py:120 msgid "IP address to use if the port has multiple addresses." msgstr "" #: heat/engine/resources/neutron/floatingip.py:59 msgid "ID of the router used as gateway, set when associated with a port." msgstr "" #: heat/engine/resources/neutron/floatingip.py:61 msgid "The tenant owning this floating IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:62 msgid "ID of the network in which this IP is allocated." msgstr "" #: heat/engine/resources/neutron/floatingip.py:64 msgid "IP address of the associated port, if specified." msgstr "" #: heat/engine/resources/neutron/floatingip.py:66 msgid "The allocated address of this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:67 msgid "ID of the port associated with this IP." msgstr "" #: heat/engine/resources/neutron/floatingip.py:110 msgid "ID of the floating IP to associate." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:46 #: heat/engine/resources/neutron/loadbalancer.py:104 msgid "The minimum time in seconds between regular connections of the member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:53 #: heat/engine/resources/neutron/loadbalancer.py:114 msgid "One of predefined health monitor types." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:61 #: heat/engine/resources/neutron/loadbalancer.py:110 msgid "" "Number of permissible connection failures before changing the member " "status to INACTIVE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:68 #: heat/engine/resources/neutron/loadbalancer.py:112 msgid "" "Maximum number of seconds for a monitor to wait for a connection to be " "established before it times out." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:75 msgid "The administrative state of the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:81 #: heat/engine/resources/neutron/loadbalancer.py:108 msgid "The HTTP method used for requests by the monitor of type HTTP." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:87 #: heat/engine/resources/neutron/loadbalancer.py:106 msgid "" "The list of HTTP status codes expected in response from the member to " "declare it healthy." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:93 #: heat/engine/resources/neutron/loadbalancer.py:115 msgid "" "The HTTP path used in the HTTP request used by the monitor to test a " "member health." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:102 msgid "The administrative state of this health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:117 msgid "Tenant owning the health monitor." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:179 msgid "Protocol for balancing." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:187 #: heat/engine/resources/neutron/loadbalancer.py:290 msgid "" "The subnet for the port on which the members of the pool will be " "connected." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:193 #: heat/engine/resources/neutron/loadbalancer.py:292 msgid "The algorithm used to distribute load between the members of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:204 #: heat/engine/resources/neutron/loadbalancer.py:288 msgid "Name of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:208 #: heat/engine/resources/neutron/loadbalancer.py:294 msgid "Description of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:213 #: heat/engine/resources/neutron/loadbalancer.py:287 msgid "The administrative state of this pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:219 msgid "IP address and port of the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:223 msgid "Name of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:227 msgid "Description of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:231 msgid "Subnet of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:235 msgid "IP address of the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:239 msgid "The maximum number of connections per second allowed for the vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:244 msgid "" "TCP port on which to listen for client traffic that is associated with " "the vip address." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:250 msgid "Configuration of session persistence." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:254 msgid "Method of implementation of session persistence feature." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:263 msgid "Name of the cookie, required if type is APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:270 msgid "The administrative state of this vip." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:278 msgid "List of health monitors associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:289 msgid "Protocol to balance." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:295 msgid "Tenant owning the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:296 msgid "Vip associated with the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:314 #: heat/tests/test_neutron_loadbalancer.py:562 msgid "" "Property cookie_name is required, when session_persistence type is set to" " APP_COOKIE." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:372 #, python-format msgid "neutron reported unexpected vip resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:377 #, python-format msgid "neutron reported unexpected pool resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:454 #: heat/engine/resources/neutron/loadbalancer.py:493 #: heat/engine/resources/neutron/loadbalancer.py:554 msgid "The ID of the load balancing pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:460 msgid "IP address of the pool member on the pool network." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:465 msgid "TCP port on which the pool member listens for requests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:474 msgid "Weight of pool member in the pool (default to 1)." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:482 msgid "The administrative state of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:488 msgid "The administrative state of this pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:490 msgid "Tenant owning the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:491 msgid "Weight of the pool member in the pool." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:492 msgid "IP address of the pool member." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:494 msgid "TCP port on which the pool member listens forrequests or connections." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:560 msgid "Port number on which the servers are running on the members." msgstr "" #: heat/engine/resources/neutron/loadbalancer.py:565 msgid "The list of Nova server IDs load balanced." msgstr "" #: heat/engine/resources/neutron/metering.py:36 #: heat/engine/resources/neutron/metering.py:45 msgid "Name of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:40 #: heat/engine/resources/neutron/metering.py:46 msgid "Description of the metering label." msgstr "" #: heat/engine/resources/neutron/metering.py:86 msgid "The metering label ID to associate with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:91 msgid "Indicates remote IP prefix to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/metering.py:97 msgid "The direction in which metering rule is applied, either ingress or egress." msgstr "" #: heat/engine/resources/neutron/metering.py:105 msgid "" "Specify whether the remote_ip_prefix will be excluded or not from traffic" " counters of the metering label. For example to not count the traffic of " "a specific IP address of a range." msgstr "" #: heat/engine/resources/neutron/metering.py:113 msgid "The direction in which metering rule is applied." msgstr "" #: heat/engine/resources/neutron/metering.py:114 msgid "Exclude state for cidr." msgstr "" #: heat/engine/resources/neutron/metering.py:115 msgid "The metering label ID to associate with this metering rule.." msgstr "" #: heat/engine/resources/neutron/metering.py:117 msgid "CIDR to be associated with this metering rule." msgstr "" #: heat/engine/resources/neutron/net.py:39 msgid "" "A string specifying a symbolic name for the network, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/net.py:45 msgid "" "Extra parameters to include in the \"network\" object in the creation " "request. Parameters are often specific to installed hardware or " "extensions." msgstr "" #: heat/engine/resources/neutron/net.py:53 msgid "A boolean value specifying the administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:60 msgid "" "The ID of the tenant which will own the network. Only administrative " "users can set the tenant identifier; this cannot be changed using " "authorization policies." msgstr "" #: heat/engine/resources/neutron/net.py:66 msgid "" "Whether this network should be shared across all tenants. Note that the " "default policy setting restricts usage of this attribute to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:74 msgid "" "The IDs of the DHCP agent to schedule the network. Note that the default " "policy setting in Neutron restricts usage of this property to " "administrative users only." msgstr "" #: heat/engine/resources/neutron/net.py:82 #: heat/engine/resources/neutron/provider_net.py:66 msgid "The status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:83 msgid "The name of the network." msgstr "" #: heat/engine/resources/neutron/net.py:84 #: heat/engine/resources/neutron/provider_net.py:67 msgid "Subnets of this network." msgstr "" #: heat/engine/resources/neutron/net.py:85 msgid "The administrative status of the network." msgstr "" #: heat/engine/resources/neutron/net.py:86 msgid "The tenant owning this network." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:56 msgid "The name of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:61 msgid "Device info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:70 msgid "The device id for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:76 msgid "The interface name for the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:85 msgid "Connection info for this network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:93 msgid "The id of internal network to connect on the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:100 msgid "L2 segmentation strategy on the external side of the network gateway." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:109 msgid "" "The id for L2 segment on the external side of the network gateway. Must " "be specified when using vlan." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:121 msgid "A boolean value of default flag." msgstr "" #: heat/engine/resources/neutron/network_gateway.py:143 msgid "segmentation_id must be specified for using vlan" msgstr "" #: heat/engine/resources/neutron/network_gateway.py:147 msgid "segmentation_id cannot be specified except 0 for using flat" msgstr "" #: heat/engine/resources/neutron/neutron.py:115 #, python-format msgid "neutron reported unexpected resource[%(name)s] status[%(status)s]" msgstr "" #: heat/engine/resources/neutron/neutron.py:124 #, python-format msgid "failed to fetch resource attributes: %s" msgstr "" #: heat/engine/resources/neutron/port.py:54 msgid "Network ID this port belongs to." msgstr "" #: heat/engine/resources/neutron/port.py:59 msgid "A symbolic name for this port." msgstr "" #: heat/engine/resources/neutron/port.py:64 msgid "" "Extra parameters to include in the \"port\" object in the creation " "request." msgstr "" #: heat/engine/resources/neutron/port.py:70 #: heat/engine/resources/neutron/port.py:138 msgid "The administrative state of this port." msgstr "" #: heat/engine/resources/neutron/port.py:76 msgid "Desired IPs for this port." msgstr "" #: heat/engine/resources/neutron/port.py:83 msgid "Subnet in which to allocate the IP address for this port." msgstr "" #: heat/engine/resources/neutron/port.py:88 msgid "IP address desired in the subnet for this port." msgstr "" #: heat/engine/resources/neutron/port.py:96 msgid "MAC address to give to this port." msgstr "" #: heat/engine/resources/neutron/port.py:100 msgid "Device ID of this port." msgstr "" #: heat/engine/resources/neutron/port.py:105 msgid "Security group IDs to associate with this port." msgstr "" #: heat/engine/resources/neutron/port.py:111 msgid "Additional MAC/IP address pairs allowed to pass through the port." msgstr "" #: heat/engine/resources/neutron/port.py:118 msgid "MAC address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:122 msgid "IP address to allow through this port." msgstr "" #: heat/engine/resources/neutron/port.py:130 msgid "" "Name of the network owning the port. The value is typically " "network:floatingip or network:router_interface or network:dhcp" msgstr "" #: heat/engine/resources/neutron/port.py:139 msgid "Unique identifier for the device." msgstr "" #: heat/engine/resources/neutron/port.py:140 msgid "Name of the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:141 msgid "Fixed IP addresses." msgstr "" #: heat/engine/resources/neutron/port.py:142 msgid "MAC address of the port." msgstr "" #: heat/engine/resources/neutron/port.py:143 msgid "Friendly name of the port." msgstr "" #: heat/engine/resources/neutron/port.py:144 msgid "Unique identifier for the network owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:145 msgid "A list of security groups for the port." msgstr "" #: heat/engine/resources/neutron/port.py:146 msgid "The status of the port." msgstr "" #: heat/engine/resources/neutron/port.py:147 msgid "Tenant owning the port." msgstr "" #: heat/engine/resources/neutron/port.py:148 msgid "Additional MAC/IP address pairs allowed to pass through a port." msgstr "" #: heat/engine/resources/neutron/port.py:228 #, python-format msgid "updating port with %s" msgstr "" #: heat/engine/resources/neutron/provider_net.py:33 msgid "A string specifying the provider network type for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:43 msgid "A string specifying physical network mapping for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:50 msgid "A string specifying the segmentation id for the network." msgstr "" #: heat/engine/resources/neutron/provider_net.py:57 msgid "Whether this network should be shared across all tenants." msgstr "" #: heat/engine/resources/neutron/provider_net.py:80 msgid "segmentation_id not allowed for flat network type." msgstr "" #: heat/engine/resources/neutron/router.py:49 msgid "The name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:54 msgid "External network gateway configuration for a router." msgstr "" #: heat/engine/resources/neutron/router.py:58 msgid "ID or name of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/router.py:64 msgid "Enables Source NAT on the router gateway." msgstr "" #: heat/engine/resources/neutron/router.py:73 #: heat/engine/resources/neutron/subnet.py:64 msgid "Extra parameters to include in the creation request." msgstr "" #: heat/engine/resources/neutron/router.py:79 msgid "The administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:85 msgid "" "ID of the L3 agent. NOTE: The default policy setting in Neutron restricts" " usage of this property to administrative users only." msgstr "" #: heat/engine/resources/neutron/router.py:93 msgid "The status of the router." msgstr "" #: heat/engine/resources/neutron/router.py:94 msgid "Gateway network for the router." msgstr "" #: heat/engine/resources/neutron/router.py:95 msgid "Friendly name of the router." msgstr "" #: heat/engine/resources/neutron/router.py:96 msgid "Administrative state of the router." msgstr "" #: heat/engine/resources/neutron/router.py:97 msgid "Tenant owning the router." msgstr "" #: heat/engine/resources/neutron/router.py:188 msgid "The router id." msgstr "" #: heat/engine/resources/neutron/router.py:193 msgid "The subnet id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:198 msgid "The port id, either subnet_id or port_id should be specified." msgstr "" #: heat/engine/resources/neutron/router.py:248 msgid "" "RouterGateway resource is deprecated and should not be used. Instead use " "the `external_gateway_info` property in the router resource to set up the" " gateway." msgstr "" #: heat/engine/resources/neutron/router.py:262 msgid "ID of the router." msgstr "" #: heat/engine/resources/neutron/router.py:267 msgid "ID of the external network for the gateway." msgstr "" #: heat/engine/resources/neutron/security_group.py:49 msgid "" "The direction in which the security group rule is applied. For a compute " "instance, an ingress security group rule matches traffic that is incoming" " (ingress) for that instance. An egress rule is applied to traffic " "leaving the instance." msgstr "" #: heat/engine/resources/neutron/security_group.py:61 msgid "Ethertype of the traffic." msgstr "" #: heat/engine/resources/neutron/security_group.py:69 msgid "" "The minimum port number in the range that is matched by the security " "group rule. If the protocol is TCP or UDP, this value must be less than " "or equal to the value of the port_range_max attribute. If the protocol is" " ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:77 msgid "" "The maximum port number in the range that is matched by the security " "group rule. The port_range_min attribute constrains the port_range_max " "attribute. If the protocol is ICMP, this value must be an ICMP type." msgstr "" #: heat/engine/resources/neutron/security_group.py:84 msgid "" "The protocol that is matched by the security group rule. Valid values " "include tcp, udp, and icmp." msgstr "" #: heat/engine/resources/neutron/security_group.py:89 msgid "Whether to specify a remote group or a remote IP prefix." msgstr "" #: heat/engine/resources/neutron/security_group.py:98 msgid "" "The remote group ID to be associated with this security group rule. If no" " value is specified then this rule will use this security group for the " "remote_group_id." msgstr "" #: heat/engine/resources/neutron/security_group.py:104 msgid "" "The remote IP prefix (CIDR) to be associated with this security group " "rule." msgstr "" #: heat/engine/resources/neutron/security_group.py:112 msgid "" "A string specifying a symbolic name for the security group, which is not " "required to be unique." msgstr "" #: heat/engine/resources/neutron/security_group.py:123 msgid "List of security group rules." msgstr "" #: heat/engine/resources/neutron/security_group.py:143 msgid "Security groups cannot be assigned the name \"default\"." msgstr "" #: heat/engine/resources/neutron/subnet.py:54 msgid "The ID of the attached network." msgstr "" #: heat/engine/resources/neutron/subnet.py:59 msgid "The CIDR." msgstr "" #: heat/engine/resources/neutron/subnet.py:70 msgid "The name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:75 msgid "The IP version, which is 4 or 6." msgstr "" #: heat/engine/resources/neutron/subnet.py:83 msgid "A specified set of DNS name servers to be used." msgstr "" #: heat/engine/resources/neutron/subnet.py:89 msgid "The gateway IP address." msgstr "" #: heat/engine/resources/neutron/subnet.py:94 msgid "Set to true if DHCP is enabled and false if DHCP is disabled." msgstr "" #: heat/engine/resources/neutron/subnet.py:100 msgid "The start and end addresses for the allocation pools." msgstr "" #: heat/engine/resources/neutron/subnet.py:117 msgid "" "The ID of the tenant who owns the network. Only administrative users can " "specify a tenant ID other than their own." msgstr "" #: heat/engine/resources/neutron/subnet.py:139 msgid "Friendly name of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:140 msgid "Parent network of the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:141 msgid "Tenant owning the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:142 msgid "Ip allocation pools and their ranges." msgstr "" #: heat/engine/resources/neutron/subnet.py:143 msgid "Ip of the subnet's gateway." msgstr "" #: heat/engine/resources/neutron/subnet.py:144 msgid "Additional routes for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:145 msgid "Ip version for the subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:146 msgid "CIDR block notation for this subnet." msgstr "" #: heat/engine/resources/neutron/subnet.py:147 msgid "List of dns nameservers." msgstr "" #: heat/engine/resources/neutron/subnet.py:148 msgid "'true' if DHCP is enabled for this subnet; 'false' otherwise." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:41 msgid "Name for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:46 msgid "Description for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:51 msgid "Administrative state for the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:57 msgid "Unique identifier for the subnet in which the vpn service will be created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:63 msgid "" "Unique identifier for the router to which the vpn service will be " "inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:70 msgid "The administrative state of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:71 msgid "The description of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:72 msgid "The name of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:73 msgid "The unique identifier of the router to which the vpn service was inserted." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:75 msgid "The status of the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:76 msgid "The unique identifier of the subnet in which the vpn service was created." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:78 msgid "The unique identifier of the tenant owning the vpn service." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:135 msgid "Name for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:140 msgid "Description for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:145 msgid "Remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:151 msgid "Remote branch router identity." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:156 msgid "Remote subnet(s) in CIDR format." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:161 msgid "Maximum transmission unit size (in bytes) for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:167 msgid "Dead Peer Detection protocol configuration for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:172 msgid "Controls DPD protocol mode." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:182 msgid "Number of seconds for the DPD delay." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:187 msgid "Number of seconds for the DPD timeout." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:194 msgid "Pre-shared key string for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:199 msgid "Initiator state in lowercase for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:207 msgid "Administrative state for the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:213 msgid "" "Unique identifier for the ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:219 msgid "" "Unique identifier for the ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:225 msgid "" "Unique identifier for the vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:232 msgid "The administrative state of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:234 msgid "The authentication mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:236 msgid "The description of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:237 msgid "" "The dead peer detection protocol configuration of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:239 msgid "" "The unique identifier of ike policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:241 msgid "The initiator of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:242 msgid "" "The unique identifier of ipsec policy associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:244 msgid "" "The maximum transmission unit size (in bytes) of the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:246 msgid "The name of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:247 msgid "The remote branch router public IPv4 address or IPv6 address or FQDN." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:249 msgid "The remote subnet(s) in CIDR format of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:251 msgid "The remote branch router identity of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:253 msgid "The pre-shared key string of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:254 msgid "The route mode of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:255 msgid "The status of the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:256 msgid "The unique identifier of the tenant owning the ipsec site connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:258 msgid "" "The unique identifier of vpn service associated with the ipsec site " "connection." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:313 msgid "Name for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:318 msgid "Description for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:323 msgid "Authentication hash algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:331 msgid "Encryption algorithm for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:340 msgid "Negotiation mode for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:348 msgid "Safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:352 #: heat/engine/resources/neutron/vpnservice.py:499 msgid "Safety assessment lifetime units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:360 #: heat/engine/resources/neutron/vpnservice.py:508 msgid "Safety assessment lifetime value in specified units." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:368 msgid "Perfect forward secrecy in lowercase for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:376 msgid "Version for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:385 msgid "The authentication hash algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:387 msgid "The description of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:388 msgid "The encryption algorithm used by the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:390 msgid "The version of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:391 msgid "The safety assessment lifetime configuration for the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:393 msgid "The name of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:394 msgid "The perfect forward secrecy of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:395 msgid "The negotiation mode of the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:397 msgid "The unique identifier of the tenant owning the ike policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:451 msgid "Name for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:456 msgid "Description for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:461 msgid "Transform protocol for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:469 msgid "Encapsulation mode for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:477 msgid "Authentication hash algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:485 msgid "Encryption algorithm for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:494 msgid "Safety assessment lifetime configuration for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:516 msgid "Perfect forward secrecy for the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:525 msgid "The authentication hash algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:527 msgid "The description of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:528 msgid "The encapsulation mode of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:529 msgid "The encryption algorithm of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:531 msgid "The safety assessment lifetime configuration of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:533 msgid "The name of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:534 msgid "The perfect forward secrecy of the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:535 msgid "The unique identifier of the tenant owning the ipsec policy." msgstr "" #: heat/engine/resources/neutron/vpnservice.py:537 msgid "The transform protocol of the ipsec policy." msgstr "" #: heat/engine/resources/software_config/cloud_config.py:44 msgid "" "Map representing the cloud-config data structure which will be formatted " "as YAML." msgstr "" #: heat/engine/resources/software_config/multi_part.py:61 msgid "Parts belonging to this messsage." msgstr "" #: heat/engine/resources/software_config/multi_part.py:68 msgid "" "Content of part to attach, either inline or by referencing the ID of " "another software config resource" msgstr "" #: heat/engine/resources/software_config/multi_part.py:75 msgid "Optional filename to associate with part." msgstr "" #: heat/engine/resources/software_config/multi_part.py:79 msgid "Whether the part content is text or multipart." msgstr "" #: heat/engine/resources/software_config/multi_part.py:85 msgid "Optional subtype to specify with the type." msgstr "" #: heat/engine/resources/software_config/software_config.py:64 msgid "Name of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:69 msgid "Description of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:73 msgid "Type of the value of the input." msgstr "" #: heat/engine/resources/software_config/software_config.py:80 msgid "Default value for the input if none is specified." msgstr "" #: heat/engine/resources/software_config/software_config.py:87 msgid "Name of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:92 msgid "Description of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:96 msgid "Type of the value of the output." msgstr "" #: heat/engine/resources/software_config/software_config.py:103 msgid "" "Denotes that the deployment is in an error state if this output has a " "value." msgstr "" #: heat/engine/resources/software_config/software_config.py:112 msgid "" "Namespace to group this software config by when delivered to a server. " "This may imply what configuration tool is going to perform the " "configuration." msgstr "" #: heat/engine/resources/software_config/software_config.py:119 msgid "" "Configuration script or manifest which specifies what actual " "configuration is performed." msgstr "" #: heat/engine/resources/software_config/software_config.py:124 msgid "" "Map containing options specific to the configuration management tool used" " by this resource." msgstr "" #: heat/engine/resources/software_config/software_config.py:129 msgid "Schema representing the inputs that this software config is expecting." msgstr "" #: heat/engine/resources/software_config/software_config.py:136 msgid "Schema representing the outputs that this software config will produce." msgstr "" #: heat/engine/resources/software_config/software_config.py:144 msgid "The config value of the software config." msgstr "" #: heat/engine/resources/software_config/software_config.py:163 #, python-format msgid "Software config %s is not found." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:108 msgid "" "ID of software configuration resource to execute when applying to the " "server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:114 msgid "ID of Nova server to apply configuration to." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:118 msgid "Input values to apply to the software configuration on this server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:124 msgid "Which stack actions will result in this deployment being triggered." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:132 msgid "" "Name of the derived config associated with this deployment. This is used " "to apply a sort order to the list of configurations currently deployed to" " a server." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:138 msgid "" "How the server should signal to heat with the deployment output values. " "CFN_SIGNAL will allow an HTTP POST to a CFN keypair signed URL. " "HEAT_SIGNAL will allow calls to the Heat API resource-signal using the " "provided keystone credentials. NO_SIGNAL will result in the resource " "going to the COMPLETE state without waiting for any signal." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:152 msgid "Captured stdout from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:153 msgid "Captured stderr from the configuration execution." msgstr "" #: heat/engine/resources/software_config/software_deployment.py:154 msgid "Returned status code from the configuration execution" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:182 msgid "Not waiting for outputs signal" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:185 msgid "Deploy data available" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:232 #, python-format msgid "Deployment to server failed: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:282 msgid "ID of the server being deployed to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:287 msgid "Name of the current action being deployed" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:292 msgid "ID of the stack this deployment belongs to" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:297 msgid "Name of this deployment resource in the stack" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:305 msgid "ID of signal to use for signalling output values" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:313 msgid "URL for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:318 msgid "Username for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:323 msgid "User ID for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:328 msgid "Password for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:333 msgid "ID of project for API authentication" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:441 #, python-format msgid "Deployment exited with non-zero status code: %s" msgstr "" #: heat/engine/resources/software_config/software_deployment.py:463 msgid "Outputs received" msgstr "" #: heat/engine/resources/software_config/structured_config.py:53 msgid "" "Map representing the configuration data structure which will be " "serialized to the chosen format." msgstr "" #: heat/engine/resources/software_config/structured_config.py:92 msgid "Name of key to use for substituting inputs during deployment" msgstr "" #: heat/openstack/common/eventlet_backdoor.py:140 #, python-format msgid "Eventlet backdoor listening on %(port)s for process %(pid)d" msgstr "" #: heat/openstack/common/excutils.py:62 #, python-format msgid "Original exception being dropped: %s" msgstr "" #: heat/openstack/common/excutils.py:91 #, python-format msgid "Unexpected exception occurred %d time(s)... retrying." msgstr "" #: heat/openstack/common/fileutils.py:62 #, python-format msgid "Reloading cached file %s" msgstr "" #: heat/openstack/common/gettextutils.py:263 msgid "Message objects do not support addition." msgstr "" #: heat/openstack/common/gettextutils.py:272 msgid "" "Message objects do not support str() because they may contain non-ascii " "characters. Please use unicode() or translate() instead." msgstr "" #: heat/openstack/common/lockutils.py:82 #, python-format msgid "Created lock path: %s" msgstr "" #: heat/openstack/common/lockutils.py:93 #, python-format msgid "Got file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:108 #, python-format msgid "Could not release the acquired lock `%s`" msgstr "" #: heat/openstack/common/lockutils.py:110 #, python-format msgid "Released file lock \"%s\"" msgstr "" #: heat/openstack/common/lockutils.py:148 #, python-format msgid "Attempting to grab external lock \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:174 #, python-format msgid "Got semaphore \"%(lock)s\"" msgstr "" #: heat/openstack/common/lockutils.py:231 #, python-format msgid "Got semaphore / lock \"%(function)s\"" msgstr "" #: heat/openstack/common/lockutils.py:235 #, python-format msgid "Semaphore / lock released \"%(function)s\"" msgstr "" #: heat/openstack/common/log.py:301 #, python-format msgid "Deprecated: %s" msgstr "" #: heat/openstack/common/log.py:404 #, python-format msgid "Error loading logging config %(log_config)s: %(err_msg)s" msgstr "" #: heat/openstack/common/log.py:455 #, python-format msgid "syslog facility must be one of: %s" msgstr "" #: heat/openstack/common/log.py:625 #, python-format msgid "Fatal call to deprecated config: %(msg)s" msgstr "" #: heat/openstack/common/loopingcall.py:82 #, python-format msgid "task run outlasted interval by %s sec" msgstr "" #: heat/openstack/common/loopingcall.py:89 msgid "in fixed duration looping call" msgstr "" #: heat/openstack/common/loopingcall.py:129 #, python-format msgid "Dynamic looping call sleeping for %.02f seconds" msgstr "" #: heat/openstack/common/loopingcall.py:136 msgid "in dynamic looping call" msgstr "" #: heat/openstack/common/policy.py:73 msgid "JSON file containing policy" msgstr "" #: heat/openstack/common/policy.py:76 msgid "Rule enforced when requested rule is not found" msgstr "" #: heat/openstack/common/policy.py:90 #, python-format msgid "Policy doesn't allow %s to be performed." msgstr "" #: heat/openstack/common/policy.py:175 #, python-format msgid "Rules must be an instance of dict or Rules, got %s instead" msgstr "" #: heat/openstack/common/policy.py:205 msgid "Rules successfully reloaded" msgstr "" #: heat/openstack/common/policy.py:251 #, python-format msgid "Rule %s will be now enforced" msgstr "" #: heat/openstack/common/policy.py:266 #, python-format msgid "Rule [%s] doesn't exist" msgstr "" #: heat/openstack/common/policy.py:474 #, python-format msgid "Failed to understand rule %s" msgstr "" #: heat/openstack/common/policy.py:484 #, python-format msgid "No handler for matches of kind %s" msgstr "" #: heat/openstack/common/policy.py:754 #, python-format msgid "Failed to understand rule %r" msgstr "" #: heat/openstack/common/processutils.py:130 #, python-format msgid "Got unknown keyword args to utils.execute: %r" msgstr "" #: heat/openstack/common/processutils.py:145 #, python-format msgid "Running cmd (subprocess): %s" msgstr "" #: heat/openstack/common/processutils.py:169 #: heat/openstack/common/processutils.py:241 #, python-format msgid "Result was %s" msgstr "" #: heat/openstack/common/processutils.py:181 #, python-format msgid "%r failed. Retrying." msgstr "" #: heat/openstack/common/processutils.py:220 #, python-format msgid "Running cmd (SSH): %s" msgstr "" #: heat/openstack/common/processutils.py:222 msgid "Environment not supported over SSH" msgstr "" #: heat/openstack/common/processutils.py:226 msgid "process_input not supported over SSH" msgstr "" #: heat/openstack/common/service.py:166 heat/openstack/common/service.py:384 msgid "Full set of CONF:" msgstr "" #: heat/openstack/common/service.py:175 heat/openstack/common/service.py:269 #, python-format msgid "Caught %s, exiting" msgstr "" #: heat/openstack/common/service.py:187 msgid "Exception during rpc cleanup." msgstr "" #: heat/openstack/common/service.py:238 msgid "Parent process has died unexpectedly, exiting" msgstr "" #: heat/openstack/common/service.py:275 msgid "Unhandled exception" msgstr "" #: heat/openstack/common/service.py:308 msgid "Forking too fast, sleeping" msgstr "" #: heat/openstack/common/service.py:327 #, python-format msgid "Started child %d" msgstr "" #: heat/openstack/common/service.py:354 #, python-format msgid "Child %(pid)d killed by signal %(sig)d" msgstr "" #: heat/openstack/common/service.py:358 #, python-format msgid "Child %(pid)s exited with status %(code)d" msgstr "" #: heat/openstack/common/service.py:362 #, python-format msgid "pid %d not in child list" msgstr "" #: heat/openstack/common/service.py:392 #, python-format msgid "Caught %s, stopping children" msgstr "" #: heat/openstack/common/service.py:410 #, python-format msgid "Waiting on %d children to exit" msgstr "" #: heat/openstack/common/sslutils.py:50 #, python-format msgid "Unable to find cert_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:53 #, python-format msgid "Unable to find ca_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:56 #, python-format msgid "Unable to find key_file : %s" msgstr "" #: heat/openstack/common/sslutils.py:98 #, python-format msgid "Invalid SSL version : %s" msgstr "" #: heat/openstack/common/strutils.py:86 #, python-format msgid "Unrecognized value '%(val)s', acceptable values are: %(acceptable)s" msgstr "" #: heat/openstack/common/strutils.py:188 #, python-format msgid "Invalid string format: %s" msgstr "" #: heat/openstack/common/strutils.py:195 #, python-format msgid "Unknown byte multiplier: %s" msgstr "" #: heat/openstack/common/versionutils.py:69 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s in favor of %(in_favor_of)s and " "may be removed in %(remove_in)s." msgstr "" #: heat/openstack/common/versionutils.py:73 #, python-format msgid "" "%(what)s is deprecated as of %(as_of)s and may be removed in " "%(remove_in)s. It will not be superseded." msgstr "" #: heat/openstack/common/crypto/utils.py:27 msgid "An unknown error occurred in crypto utils." msgstr "" #: heat/openstack/common/crypto/utils.py:34 #, python-format msgid "Block size of %(given)d is too big, max = %(maximum)d" msgstr "" #: heat/openstack/common/crypto/utils.py:43 #, python-format msgid "Length of %(given)d is too long, max = %(maximum)d" msgstr "" #: heat/openstack/common/db/exception.py:42 msgid "Invalid Parameter: Unicode is not supported by the current database." msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:219 msgid "version should be an integer" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:242 #, python-format msgid "" "Tables \"%s\" have non utf8 collation, please make sure all tables are " "CHARSET=utf8" msgstr "" #: heat/openstack/common/db/sqlalchemy/migration.py:266 msgid "" "The database is not under version control, but has tables. Please stamp " "the current version of the schema manually." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:596 msgid "DB exception wrapped." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:665 #, python-format msgid "Database server has gone away: %s" msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:743 msgid "" "This application has not enabled MySQL traditional mode, which means " "silent data corruption may occur. Please encourage the application " "developers to enable this mode." msgstr "" #: heat/openstack/common/db/sqlalchemy/session.py:767 #, python-format msgid "SQL connection failed. %s attempts left." msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:103 #, python-format msgid "Got lock \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/test_migrations.py:106 #, python-format msgid "Lock released \"%s\"" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:58 msgid "Sort key supplied was not valid." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:97 msgid "Id not in sort_keys; is sort_keys unique?" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:119 msgid "Unknown sort direction, must be 'desc' or 'asc'" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:194 #, python-format msgid "" "Please specify column %s in col_name_col_instance param. It is required " "because column has unsupported type by sqlite)." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:200 #, python-format msgid "" "col_name_col_instance param has wrong type of column instance for column " "%s It should be instance of sqlalchemy.Column." msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:280 #, python-format msgid "Deleting duplicated row with id: %(id)s from table: %(table)s" msgstr "" #: heat/openstack/common/db/sqlalchemy/utils.py:301 msgid "Unsupported id columns type" msgstr "" #: heat/openstack/common/notifier/api.py:129 #, python-format msgid "%s not in valid priorities" msgstr "" #: heat/openstack/common/notifier/api.py:145 #, python-format msgid "" "Problem '%(e)s' attempting to send to notification system. " "Payload=%(payload)s" msgstr "" #: heat/openstack/common/notifier/api.py:164 #, python-format msgid "Failed to load notifier %s. These notifications will not be sent." msgstr "" #: heat/openstack/common/notifier/list_notifier.py:112 #, python-format msgid "Problem '%(e)s' attempting to send to notification driver %(driver)s." msgstr "" #: heat/openstack/common/notifier/rabbit_notifier.py:27 msgid "The rabbit_notifier is now deprecated. Please use rpc_notifier instead." msgstr "" #: heat/openstack/common/notifier/rpc_notifier.py:45 #: heat/openstack/common/notifier/rpc_notifier2.py:51 #, python-format msgid "Could not send notification to %(topic)s. Payload=%(message)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:75 msgid "Pool creating new connection" msgstr "" #: heat/openstack/common/rpc/amqp.py:202 #, python-format msgid "No calling threads waiting for msg_id : %(msg_id)s, message : %(data)s" msgstr "" #: heat/openstack/common/rpc/amqp.py:205 #, python-format msgid "_call_waiters: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:212 #, python-format msgid "" "Number of call waiters is greater than warning threshold: %d. There could" " be a MulticallProxyWaiter leak." msgstr "" #: heat/openstack/common/rpc/amqp.py:290 #, python-format msgid "unpacked context: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:342 #, python-format msgid "UNIQUE_ID is %s." msgstr "" #: heat/openstack/common/rpc/amqp.py:435 #, python-format msgid "received %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:443 #, python-format msgid "no method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:444 #, python-format msgid "No method for message: %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:472 #: heat/openstack/common/rpc/impl_zmq.py:280 #, python-format msgid "Expected exception during message handling (%s)" msgstr "" #: heat/openstack/common/rpc/amqp.py:480 #: heat/openstack/common/rpc/impl_zmq.py:286 msgid "Exception during message handling" msgstr "" #: heat/openstack/common/rpc/amqp.py:554 #, python-format msgid "Making synchronous call on %s ..." msgstr "" #: heat/openstack/common/rpc/amqp.py:557 #, python-format msgid "MSG_ID is %s" msgstr "" #: heat/openstack/common/rpc/amqp.py:583 #, python-format msgid "Making asynchronous cast on %s..." msgstr "" #: heat/openstack/common/rpc/amqp.py:592 msgid "Making asynchronous fanout cast..." msgstr "" #: heat/openstack/common/rpc/amqp.py:620 #, python-format msgid "Sending %(event_type)s on %(topic)s" msgstr "" #: heat/openstack/common/rpc/common.py:76 msgid "An unknown RPC related exception occurred." msgstr "" #: heat/openstack/common/rpc/common.py:106 #, python-format msgid "" "Remote error: %(exc_type)s %(value)s\n" "%(traceback)s." msgstr "" #: heat/openstack/common/rpc/common.py:123 #, python-format msgid "" "Timeout while waiting on RPC response - topic: \"%(topic)s\", RPC method:" " \"%(method)s\" info: \"%(info)s\"" msgstr "" #: heat/openstack/common/rpc/common.py:140 #: heat/openstack/common/rpc/common.py:141 #: heat/openstack/common/rpc/common.py:142 msgid "" msgstr "" #: heat/openstack/common/rpc/common.py:146 #, python-format msgid "Found duplicate message(%(msg_id)s). Skipping it." msgstr "" #: heat/openstack/common/rpc/common.py:150 msgid "Invalid reuse of an RPC connection." msgstr "" #: heat/openstack/common/rpc/common.py:154 #, python-format msgid "Specified RPC version, %(version)s, not supported by this endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:159 #, python-format msgid "" "Specified RPC envelope version, %(version)s, not supported by this " "endpoint." msgstr "" #: heat/openstack/common/rpc/common.py:164 #, python-format msgid "Specified RPC version cap, %(version_cap)s, is too low" msgstr "" #: heat/openstack/common/rpc/common.py:292 #, python-format msgid "Returning exception %s to caller" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:156 msgid "Failed to process message ... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:160 msgid "Failed to process message ... will requeue." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:495 #, python-format msgid "Reconnecting to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:517 #, python-format msgid "Connected to AMQP server on %(hostname)s:%(port)d" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:554 #, python-format msgid "" "Unable to connect to AMQP server on %(hostname)s:%(port)d after " "%(max_retries)d tries: %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:568 #, python-format msgid "" "AMQP server on %(hostname)s:%(port)d is unreachable: %(err_str)s. Trying " "again in %(sleep_time)d seconds." msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:622 #: heat/openstack/common/rpc/impl_qpid.py:573 #, python-format msgid "Failed to declare consumer for topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:640 #: heat/openstack/common/rpc/impl_qpid.py:588 #, python-format msgid "Timed out waiting for RPC response: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:644 #: heat/openstack/common/rpc/impl_qpid.py:592 #, python-format msgid "Failed to consume message from queue: %s" msgstr "" #: heat/openstack/common/rpc/impl_kombu.py:683 #: heat/openstack/common/rpc/impl_qpid.py:627 #, python-format msgid "Failed to publish message to topic '%(topic)s': %(err_str)s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:87 #, python-format msgid "Invalid value for qpid_topology_version: %d" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:191 msgid "Failed to process message... skipping it." msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:515 #, python-format msgid "Unable to connect to AMQP server: %(e)s. Sleeping %(delay)s seconds" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:521 #, python-format msgid "Connected to AMQP server on %s" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:534 msgid "Re-established AMQP queues" msgstr "" #: heat/openstack/common/rpc/impl_qpid.py:600 msgid "Error processing message. Skipping it." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:96 msgid "JSON serialization failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:101 #, python-format msgid "Deserializing: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:136 #, python-format msgid "Connecting to %(addr)s with %(type)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:137 #, python-format msgid "-> Subscribed to %(subscribe)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:138 #, python-format msgid "-> bind: %(bind)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:146 msgid "Could not open socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:158 #, python-format msgid "Subscribing to %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:195 msgid "ZeroMQ socket could not be closed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:200 msgid "You cannot recv on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:205 msgid "You cannot send on this socket." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:267 #, python-format msgid "Running func with context: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:305 msgid "Sending reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:339 msgid "RPC message did not include method." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:371 msgid "Registering reactor" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:383 msgid "In reactor registered" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:388 msgid "Consuming socket" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:438 #, python-format msgid "Creating proxy for topic: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:444 msgid "Topic contained dangerous characters." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:476 msgid "Topic socket file creation failed." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:482 #, python-format msgid "Local per-topic backlog buffer full for topic %(topic)s. Dropping message." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:498 #, python-format msgid "Required IPC directory does not exist at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:507 #, python-format msgid "Permission denied to IPC directory at %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:510 msgid "Could not create ZeroMQ receiver daemon. Socket may already be in use." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:544 #, python-format msgid "CONSUMER RECEIVED DATA: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:563 msgid "ZMQ Envelope version unsupported or unknown." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:591 msgid "Skipping topic registration. Already registered." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:598 #, python-format msgid "Consumer is a zmq.%s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:650 msgid "Creating payload" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:663 msgid "Creating queue socket for reply waiter" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:676 msgid "Sending cast" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:679 msgid "Cast sent; Waiting reply" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:682 #, python-format msgid "Received message: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:683 msgid "Unpacking response" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:692 msgid "Unsupported or unknown ZMQ envelope returned." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:699 msgid "RPC Message Invalid." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:722 #, python-format msgid "%(msg)s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:725 #, python-format msgid "Sending message(s) to: %s" msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:729 msgid "No matchmaker results. Not casting." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:732 msgid "No match from matchmaker." msgstr "" #: heat/openstack/common/rpc/impl_zmq.py:814 #, python-format msgid "rpc_zmq_matchmaker = %(orig)s is deprecated; use %(new)s instead" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:46 msgid "Match not found by MatchMaker." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:80 msgid "Matchmaker does not implement registration or heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker.py:216 #, python-format msgid "Matchmaker unregistered: %(key)s, %(host)s" msgstr "" #: heat/openstack/common/rpc/matchmaker.py:228 msgid "Register before starting heartbeat." msgstr "" #: heat/openstack/common/rpc/matchmaker_ring.py:76 #: heat/openstack/common/rpc/matchmaker_ring.py:94 #, python-format msgid "No key defining hosts for topic '%s', see ringfile" msgstr "" #: heat/openstack/common/rpc/service.py:47 #, python-format msgid "Creating Consumer connection for Service %s" msgstr "" #: heat/tests/generic_resource.py:32 #, python-format msgid "Creating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:36 #, python-format msgid "Updating generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:40 #, python-format msgid "Deleting generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:47 #, python-format msgid "Suspending generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:51 #, python-format msgid "Resuming generic resource (Type \"%s\")" msgstr "" #: heat/tests/generic_resource.py:118 #, python-format msgid "Signaled resource (Type \"%(type)s\") %(details)s" msgstr "" #: heat/tests/test_exception.py:24 #, python-format msgid "Testing message %(text)s" msgstr "" #: heat/tests/test_server.py:814 #, python-format msgid "" "Properties \"uuid\" and \"network\" are both set to the network " "\"%(network)s\" for the server \"%(server)s\". The \"uuid\" property is " "deprecated. Use only \"network\" property." msgstr "" #: heat/tests/test_validate.py:1170 msgid "The InstanceType parameter must be assigned to one Parameter Group only." msgstr "" #: heat/tests/test_validate.py:1185 msgid "" "The Parameter name (SomethingNotHere) does not reference an existing " "parameter." msgstr "" heat-2014.1.5/heat/cloudinit/0000775000567000056700000000000012540643116016742 5ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/cloudinit/part_handler.py0000664000567000056700000000317112540642614021763 0ustar jenkinsjenkins00000000000000#part-handler # 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. import datetime import errno import os import sys def list_types(): return(["text/x-cfninitdata"]) def handle_part(data, ctype, filename, payload): if ctype == "__begin__": try: os.makedirs('/var/lib/heat-cfntools', int("700", 8)) except OSError: ex_type, e, tb = sys.exc_info() if e.errno != errno.EEXIST: raise return if ctype == "__end__": return log = open('/var/log/part-handler.log', 'a') try: timestamp = datetime.datetime.now() log.write('%s filename:%s, ctype:%s\n' % (timestamp, filename, ctype)) finally: log.close() if ctype == 'text/x-cfninitdata': f = open('/var/lib/heat-cfntools/%s' % filename, 'w') try: f.write(payload) finally: f.close() # TODO(sdake) hopefully temporary until users move to heat-cfntools-1.3 f = open('/var/lib/cloud/data/%s' % filename, 'w') try: f.write(payload) finally: f.close() heat-2014.1.5/heat/cloudinit/__init__.py0000664000567000056700000000000012540642611021040 0ustar jenkinsjenkins00000000000000heat-2014.1.5/heat/cloudinit/boothook.sh0000775000567000056700000000105012540642611021120 0ustar jenkinsjenkins00000000000000#!/bin/bash # FIXME(shadower) this is a workaround for cloud-init 0.6.3 present in Ubuntu # 12.04 LTS: # https://bugs.launchpad.net/heat/+bug/1257410 # # The old cloud-init doesn't create the users directly so the commands to do # this are injected though nova_utils.py. # # Once we drop support for 0.6.3, we can safely remove this. ${add_custom_user} # in case heat-cfntools has been installed from package but no symlinks # are yet in /opt/aws/bin/ cfn-create-aws-symlinks # Do not remove - the cloud boothook should always return success exit 0 heat-2014.1.5/heat/cloudinit/loguserdata.py0000775000567000056700000000574012540642614021641 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # 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. import datetime from distutils.version import LooseVersion import errno import logging import os import pkg_resources import subprocess import sys VAR_PATH = '/var/lib/heat-cfntools' LOG = logging.getLogger('heat-provision') def chk_ci_version(): v = LooseVersion(pkg_resources.get_distribution('cloud-init').version) return v >= LooseVersion('0.6.0') def init_logging(): LOG.setLevel(logging.INFO) LOG.addHandler(logging.StreamHandler()) fh = logging.FileHandler("/var/log/heat-provision.log") os.chmod(fh.baseFilename, int("600", 8)) LOG.addHandler(fh) def call(args): class LogStream(object): def write(self, data): LOG.info(data) LOG.info('%s\n' % ' '.join(args)) try: ls = LogStream() p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) data = p.communicate() if data: for x in data: ls.write(x) except OSError: ex_type, ex, tb = sys.exc_info() if ex.errno == errno.ENOEXEC: LOG.error('Userdata empty or not executable: %s\n' % str(ex)) return os.EX_OK else: LOG.error('OS error running userdata: %s\n' % str(ex)) return os.EX_OSERR except Exception: ex_type, ex, tb = sys.exc_info() LOG.error('Unknown error running userdata: %s\n' % str(ex)) return os.EX_SOFTWARE return p.returncode def main(): if not chk_ci_version(): # pre 0.6.0 - user data executed via cloudinit, not this helper LOG.error('Unable to log provisioning, need a newer version of' ' cloud-init\n') return -1 userdata_path = os.path.join(VAR_PATH, 'cfn-userdata') os.chmod(userdata_path, int("700", 8)) LOG.info('Provision began: %s\n' % datetime.datetime.now()) returncode = call([userdata_path]) LOG.info('Provision done: %s\n' % datetime.datetime.now()) if returncode: return returncode if __name__ == '__main__': init_logging() code = main() if code: LOG.error('Provision failed with exit code %s' % code) sys.exit(code) provision_log = os.path.join(VAR_PATH, 'provision-finished') # touch the file so it is timestamped with when finished pl = file(provision_log, 'a') try: os.utime(provision_log, None) finally: pl.close() heat-2014.1.5/heat/cloudinit/config0000664000567000056700000000025312540642611020131 0ustar jenkinsjenkins00000000000000${add_custom_user} # Capture all subprocess output into a logfile # Useful for troubleshooting cloud-init issues output: {all: '| tee -a /var/log/cloud-init-output.log'} heat-2014.1.5/babel.cfg0000664000567000056700000000002012540642611015544 0ustar jenkinsjenkins00000000000000[python: **.py] heat-2014.1.5/.coveragerc0000664000567000056700000000015312540642611016146 0ustar jenkinsjenkins00000000000000[run] branch = True source = heat,contrib omit = */tests/*,heat/openstack/* [report] ignore-errors = True heat-2014.1.5/bin/0000775000567000056700000000000012540643116014577 5ustar jenkinsjenkins00000000000000heat-2014.1.5/bin/heat-api-cloudwatch0000775000567000056700000000466212540642614020362 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # # 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 API Server. This implements an approximation of the Amazon CloudWatch API and translates it into a native representation. It then calls the heat-engine via AMQP RPC to implement them. """ import eventlet eventlet.monkey_patch(os=False) import os import sys # If ../heat/__init__.py exists, add ../ to Python search path, so that # it will override what happens to be installed in /usr/(local/)lib/python... possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)) if os.path.exists(os.path.join(possible_topdir, 'heat', '__init__.py')): sys.path.insert(0, possible_topdir) from heat.openstack.common import gettextutils gettextutils.install('heat', lazy=False) from oslo.config import cfg from heat.common import config from heat.common import wsgi from heat.common import notify from heat.openstack.common import log as logging LOG = logging.getLogger('heat.api.cloudwatch') if __name__ == '__main__': try: cfg.CONF(project='heat', prog='heat-api-cloudwatch') cfg.CONF.default_log_levels = ['amqplib=WARN', 'qpid.messaging=INFO', 'keystone=INFO', 'eventlet.wsgi.server=WARN', ] logging.setup('heat') app = config.load_paste_app() port = cfg.CONF.heat_api_cloudwatch.bind_port host = cfg.CONF.heat_api_cloudwatch.bind_host LOG.info('Starting Heat CloudWatch API on %s:%s' % (host, port)) server = wsgi.Server() server.start(app, cfg.CONF.heat_api_cloudwatch, default_port=port) notify.startup_notify(cfg.CONF.onready) server.wait() except RuntimeError as e: sys.exit("ERROR: %s" % e) heat-2014.1.5/bin/heat-api0000775000567000056700000000434612540642614016226 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # # 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 API Server. An OpenStack ReST API to Heat. """ import eventlet eventlet.monkey_patch(os=False) import os import sys # If ../heat/__init__.py exists, add ../ to Python search path, so that # it will override what happens to be installed in /usr/(local/)lib/python... possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)) if os.path.exists(os.path.join(possible_topdir, 'heat', '__init__.py')): sys.path.insert(0, possible_topdir) from heat.openstack.common import gettextutils gettextutils.install('heat', lazy=False) from oslo.config import cfg from heat.common import config from heat.common import wsgi from heat.common import notify from heat.openstack.common import log as logging LOG = logging.getLogger('heat.api') if __name__ == '__main__': try: cfg.CONF(project='heat', prog='heat-api') cfg.CONF.default_log_levels = ['amqplib=WARN', 'qpid.messaging=INFO', 'keystone=INFO', 'eventlet.wsgi.server=WARN', ] logging.setup('heat') app = config.load_paste_app() port = cfg.CONF.heat_api.bind_port host = cfg.CONF.heat_api.bind_host LOG.info('Starting Heat ReST API on %s:%s' % (host, port)) server = wsgi.Server() server.start(app, cfg.CONF.heat_api, default_port=port) notify.startup_notify(cfg.CONF.onready) server.wait() except RuntimeError as e: sys.exit("ERROR: %s" % e) heat-2014.1.5/bin/cinder-keystone-setup0000775000567000056700000000074312540642614020774 0ustar jenkinsjenkins00000000000000#!/bin/bash set +e SERVICE_PASSWORD='servicepass' CINDER_USERNAME='cinder' source `dirname $0`/heat-keystone-setup ADMIN_ROLE=$(get_data 2 admin 1 keystone role-list) SERVICE_TENANT=$(get_data 2 service 1 keystone tenant-list) CINDER_USERID=$(get_user $CINDER_USERNAME) add_role $CINDER_USERID $SERVICE_TENANT $ADMIN_ROLE $CINDER_USERNAME CINDER_SERVICE=$(get_service cinder volume "Cinder Volume Service") add_endpoint $CINDER_SERVICE 'http://localhost:8776/v1/$(tenant_id)s' heat-2014.1.5/bin/heat-keystone-setup0000775000567000056700000002336312540642614020454 0ustar jenkinsjenkins00000000000000#!/bin/bash set +e KEYSTONE_CONF=${KEYSTONE_CONF:-/etc/keystone/keystone.conf} # Extract some info from Keystone's configuration file if [[ -r "$KEYSTONE_CONF" ]]; then CONFIG_SERVICE_TOKEN=$(sed 's/[[:space:]]//g' $KEYSTONE_CONF | grep ^admin_token= | cut -d'=' -f2) CONFIG_ADMIN_PORT=$(sed 's/[[:space:]]//g' $KEYSTONE_CONF | grep ^admin_port= | cut -d'=' -f2) fi SERVICE_TOKEN=${OS_SERVICE_TOKEN:-$CONFIG_SERVICE_TOKEN} SERVICE_ENDPOINT=${OS_SERVICE_ENDPOINT:-http://127.0.0.1:${CONFIG_ADMIN_PORT:-35357}/v2.0} if [[ -z "$SERVICE_TOKEN" ]]; then echo "No service token found." >&2 echo "Set SERVICE_TOKEN manually from keystone.conf admin_token." >&2 exit 1 fi set_admin_token() { alias keystone="keystone --token $SERVICE_TOKEN \ --endpoint $SERVICE_ENDPOINT" } unset_admin_token() { unalias keystone } #### utilities functions merged from devstack to check required parameter is not empty # Prints line number and "message" in error format # err $LINENO "message" function err() { local exitcode=$? errXTRACE=$(set +o | grep xtrace) set +o xtrace local msg="[ERROR] ${BASH_SOURCE[2]}:$1 $2" echo $msg 1>&2; if [[ -n ${SCREEN_LOGDIR} ]]; then echo $msg >> "${SCREEN_LOGDIR}/error.log" fi $errXTRACE return $exitcode } # Prints backtrace info # filename:lineno:function function backtrace { local level=$1 local deep=$((${#BASH_SOURCE[@]} - 1)) echo "[Call Trace]" while [ $level -le $deep ]; do echo "${BASH_SOURCE[$deep]}:${BASH_LINENO[$deep-1]}:${FUNCNAME[$deep-1]}" deep=$((deep - 1)) done } # Prints line number and "message" then exits # die $LINENO "message" function die() { local exitcode=$? set +o xtrace local line=$1; shift if [ $exitcode == 0 ]; then exitcode=1 fi backtrace 2 err $line "$*" exit $exitcode } # Checks an environment variable is not set or has length 0 OR if the # exit code is non-zero and prints "message" and exits # NOTE: env-var is the variable name without a '$' # die_if_not_set $LINENO env-var "message" function die_if_not_set() { local exitcode=$? FXTRACE=$(set +o | grep xtrace) set +o xtrace local line=$1; shift local evar=$1; shift if ! is_set $evar || [ $exitcode != 0 ]; then die $line "$*" fi $FXTRACE } # Test if the named environment variable is set and not zero length # is_set env-var function is_set() { local var=\$"$1" eval "[ -n \"$var\" ]" # For ex.: sh -c "[ -n \"$var\" ]" would be better, but several exercises depends on this } ####################################### get_data() { local match_column=$(($1 + 1)) local regex="$2" local output_column=$(($3 + 1)) shift 3 output=$("$@" | \ awk -F'|' \ "! /^\+/ && \$${match_column} ~ \"^ *${regex} *\$\" \ { print \$${output_column} }") echo "$output" } get_id () { get_data 1 id 2 "$@" } get_column_num() { local name=$1 shift $@ | awk -F'|' "NR == 2 && /^|/ { for (i=2; i&2 echo $user_id else echo "Creating $username user..." >&2 get_id keystone user-create --name=$username \ --pass="$SERVICE_PASSWORD" \ --tenant_id $SERVICE_TENANT \ --email=$username@example.com fi } add_role() { local user_id=$1 local tenant=$2 local role_id=$3 local username=$4 # The keystone argument format changed between essex and folsom # so we use the fact that the folsom keystone version has a new # option "user-role-list" to detect we're on that newer version # This also allows us to detect when the user already has the # requested role_id, preventing an error on folsom user_roles=$(keystone user-role-list \ --user_id $user_id\ --tenant_id $tenant 2>/dev/null) die_if_not_set $LINENO user_roles "Fail to get user_roles for tenant($tenant) and user_id($user_id)" if [ $? == 0 ]; then # Folsom existing_role=$(get_data 1 $role_id 1 echo "$user_roles") if [ -n "$existing_role" ] then echo "User $username already has role $role_id" >&2 return fi keystone user-role-add --tenant_id $tenant \ --user_id $user_id \ --role_id $role_id else # Essex keystone user-role-add --tenant_id $tenant \ --user $user_id \ --role $role_id fi } create_role() { local role_name=$1 role_id=$(get_data 2 $role_name 1 keystone role-list) if [ -n "$role_id" ] then echo "Role $role_name already exists : $role_id" >&2 else keystone role-create --name $role_name fi } get_endpoint() { local service_type=$1 unset_admin_token keystone endpoint-get --service $service_type set_admin_token } delete_endpoint() { local service_type=$1 case $service_type in volume) urlsuffix='\\\\$\\\\(tenant_id)s';; orchestration) urlsuffix='%[(]tenant_id[)]s';; # cloudformation has no hash suffix *) urlsuffix='' esac local url=$(get_data 1 "${service_type}[.]publicURL" 2 \ get_endpoint $service_type 2>/dev/null | \ sed -r "s/[a-f0-9]{32}/$urlsuffix/") if [ -n "$url" ]; then local endpoints=$(get_data 3 $url 1 keystone endpoint-list) for endpoint in $endpoints; do echo "Removing $service_type endpoint ${endpoint}..." >&2 keystone endpoint-delete "$endpoint" >&2 done if [ -z "$endpoints" ]; then false; fi else false fi } delete_all_endpoints() { while delete_endpoint $1; do true done } delete_service() { local service_type=$1 delete_all_endpoints $service_type local service_ids=$(get_data 3 $service_type 1 keystone service-list) for service in $service_ids; do local service_name=$(get_data 1 $service 2 keystone service-list) echo "Removing $service_name:$service_type service..." >&2 keystone service-delete $service >&2 done } get_service() { local service_name=$1 local service_type=$2 local description="$3" delete_service $service_type get_id keystone service-create --name=$service_name \ --type=$service_type \ --description="$description" } add_endpoint() { local service_id=$1 local url="$2" keystone endpoint-create --region RegionOne --service_id $service_id \ --publicurl "$url" --adminurl "$url" --internalurl "$url" >&2 } keystone_setup() { # Make sure we can use keystone command without OS_SERVICE_TOKEN and OS_SERVICE_ENDPOINT # credential, because we need to use keystone endpoint-get command below, and the # keystone endpoint-get command can not run correctly # using OS_SERVICE_TOKEN and OS_SERVICE_ENDPOINT credential. unset OS_SERVICE_TOKEN unset OS_SERVICE_ENDPOINT TENANT_ID=$(get_data 1 tenant_id 2 keystone token-get) die_if_not_set $LINENO TENANT_ID "Fail to get TENANT_ID by 'token-get' " set_admin_token ADMIN_ROLE=$(get_data 2 admin 1 keystone role-list) die_if_not_set $LINENO ADMIN_ROLE "Fail to get ADMIN_ROLE by 'keystone role-list' " SERVICE_TENANT=$(get_data 2 service 1 keystone tenant-list) die_if_not_set $LINENO SERVICE_TENANT "Fail to get service tenant 'keystone tenant-list' " SERVICE_PASSWORD=${SERVICE_PASSWORD:-$OS_PASSWORD} SERVICE_HOST=${SERVICE_HOST:-localhost} if [[ "$SERVICE_PASSWORD" == "$OS_PASSWORD" ]]; then echo "Using the OS_PASSWORD for the SERVICE_PASSWORD." >&2 fi if [[ "$SERVICE_HOST" == "localhost" ]]; then echo "Warning: Endpoints will be registered as localhost, but this usually won't work." echo "Set SERVICE_HOST to a publicly accessible hostname/IP instead." fi echo ADMIN_ROLE $ADMIN_ROLE echo SERVICE_TENANT $SERVICE_TENANT echo SERVICE_PASSWORD $SERVICE_PASSWORD echo SERVICE_TOKEN $SERVICE_TOKEN echo SERVICE_HOST $SERVICE_HOST HEAT_USERNAME="heat" HEAT_USERID=$(get_user $HEAT_USERNAME) die_if_not_set $LINENO HEAT_USERID "Fail to get user for $HEAT_USERNAME" echo HEAT_USERID $HEAT_USERID add_role $HEAT_USERID $SERVICE_TENANT $ADMIN_ROLE $HEAT_USERNAME # Create a special role which template-defined "stack users" are # assigned to in the engine when they are created, this allows them # to be more easily differentiated from other users (e.g so we can # lock down these implicitly untrusted users via RBAC policy) STACK_USER_ROLE="heat_stack_user" create_role $STACK_USER_ROLE HEAT_CFN_SERVICE=$(get_service heat-cfn cloudformation \ "Heat CloudFormation API") add_endpoint $HEAT_CFN_SERVICE "http://$SERVICE_HOST:8000/v1" HEAT_OS_SERVICE=$(get_service heat orchestration \ "Heat API") add_endpoint $HEAT_OS_SERVICE "http://$SERVICE_HOST:8004/v1/%(tenant_id)s" } if [[ ${BASH_SOURCE[0]} == ${0} ]]; then keystone_setup fi heat-2014.1.5/bin/heat-db-setup0000775000567000056700000001514712540642614017201 0ustar jenkinsjenkins00000000000000#!/bin/bash # # 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. # # # Print --help output and exit. # usage() { cat << EOF Set up a local MySQL database for use with heat. This script will create a 'heat' database that is accessible only on localhost by user 'heat' with password 'heat'. Usage: heat-db-setup [options] Options: select a distro type (rpm or debian) --help | -h Print usage information. --password | -p Specify the password for the 'heat' MySQL user that will use to connect to the 'heat' MySQL database. By default, the password 'heat' will be used. --rootpw | -r 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. --yes | -y 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. EOF exit 0 } install_mysql_server() { if [ -z "${ASSUME_YES}" ] ; then $PACKAGE_INSTALL mysql-server else $PACKAGE_INSTALL -y mysql-server fi } start_mysql_server() { $SERVICE_START } MYSQL_HEAT_PW_DEFAULT="heat" MYSQL_HEAT_PW=${MYSQL_HEAT_PW_DEFAULT} HEAT_CONFIG="/etc/heat/heat.conf" ASSUME_YES="" ELEVATE="" # Check for root privileges if [[ $EUID -ne 0 ]] ; then echo "This operation requires superuser privileges, using sudo:" if sudo -l > /dev/null ; then ELEVATE="sudo" else exit 1 fi fi case "$1" in rpm) echo "Installing on an RPM system." PACKAGE_INSTALL="$ELEVATE yum install" PACKAGE_STATUS="rpm -q" SERVICE_MYSQLD="mysqld" SERVICE_START="$ELEVATE service $SERVICE_MYSQLD start" SERVICE_STATUS="service $SERVICE_MYSQLD status" SERVICE_ENABLE="$ELEVATE chkconfig" ;; deb) echo "Installing on a Debian system." PACKAGE_INSTALL="$ELEVATE apt-get install" PACKAGE_STATUS="dpkg-query -s" SERVICE_MYSQLD="mysql" SERVICE_START="$ELEVATE service $SERVICE_MYSQLD start" SERVICE_STATUS="$ELEVATE service $SERVICE_MYSQLD status" SERVICE_ENABLE="" ;; *) usage ;; esac while [ $# -gt 0 ] do case "$1" in -h|--help) usage ;; -p|--password) shift MYSQL_HEAT_PW=${1} ;; -r|--rootpw) shift MYSQL_ROOT_PW=${1} ;; -y|--yes) ASSUME_YES="yes" ;; *) # ignore ;; esac shift done # Make sure MySQL is installed. NEW_MYSQL_INSTALL=0 if ! $PACKAGE_STATUS mysql-server && ! $PACKAGE_STATUS mariadb-server > /dev/null then if [ -z "${ASSUME_YES}" ] ; then printf "mysql-server is not installed. Would you like to install it now? (y/n): " read response case "$response" in y|Y) ;; n|N) echo "mysql-server must be installed. Please install it before proceeding." exit 0 ;; *) echo "Invalid response." exit 1 esac fi NEW_MYSQL_INSTALL=1 install_mysql_server fi # Make sure mysqld is running. if ! $SERVICE_STATUS > /dev/null then if [ -z "${ASSUME_YES}" ] ; then printf "$SERVICE_MYSQLD is not running. Would you like to start it now? (y/n): " read response case "$response" in y|Y) ;; n|N) echo "$SERVICE_MYSQLD must be running. Please start it before proceeding." exit 0 ;; *) echo "Invalid response." exit 1 esac fi start_mysql_server # If we both installed and started, ensure it starts at boot [ $NEW_MYSQL_INSTALL -eq 1 ] && $SERVICE_ENABLE $SERVICE_MYSQLD on fi # Get MySQL root access. if [ $NEW_MYSQL_INSTALL -eq 1 ] then if [ ! "${MYSQL_ROOT_PW+defined}" ] ; then echo "Since this is a fresh installation of MySQL, please set a password for the 'root' mysql user." PW_MATCH=0 while [ $PW_MATCH -eq 0 ] do printf "Enter new password for 'root' mysql user: " read -s MYSQL_ROOT_PW echo printf "Enter new password again: " read -s PW2 echo if [ "${MYSQL_ROOT_PW}" = "${PW2}" ] ; then PW_MATCH=1 else echo "Passwords did not match." fi done fi echo "UPDATE mysql.user SET password = password('${MYSQL_ROOT_PW}') WHERE user = 'root'; DELETE FROM mysql.user WHERE user = ''; flush privileges;" | mysql -u root if ! [ $? -eq 0 ] ; then echo "Failed to set password for 'root' MySQL user." exit 1 fi elif [ ! "${MYSQL_ROOT_PW+defined}" ] ; then printf "Please enter the password for the 'root' MySQL user: " read -s MYSQL_ROOT_PW echo fi # Sanity check MySQL credentials. MYSQL_ROOT_PW_ARG="" if [ "${MYSQL_ROOT_PW+defined}" ] then MYSQL_ROOT_PW_ARG="--password=${MYSQL_ROOT_PW}" fi echo "SELECT 1;" | mysql -u root ${MYSQL_ROOT_PW_ARG} > /dev/null if ! [ $? -eq 0 ] then echo "Failed to connect to the MySQL server. Please check your root user credentials." exit 1 fi echo "Verified connectivity to MySQL." # Now create the db. echo "Creating 'heat' database." cat << EOF | mysql -u root ${MYSQL_ROOT_PW_ARG} CREATE DATABASE IF NOT EXISTS heat DEFAULT CHARACTER SET utf8; GRANT ALL ON heat.* TO 'heat'@'localhost' IDENTIFIED BY '${MYSQL_HEAT_PW}'; GRANT ALL ON heat.* TO 'heat'@'%' IDENTIFIED BY '${MYSQL_HEAT_PW}'; flush privileges; EOF # Make sure heat configuration has the right MySQL password. if [ "${MYSQL_HEAT_PW}" != "${MYSQL_HEAT_PW_DEFAULT}" ] ; then echo "Updating 'heat' database password in ${HEAT_CONFIG}" sed -i -e "s/mysql:\/\/heat:\(.*\)@/mysql:\/\/heat:${MYSQL_HEAT_PW}@/" ${HEAT_CONFIG} fi # override the logging config in heat.conf log_conf=$(mktemp /tmp/heat-logging.XXXXXXXXXX.conf) cat < $log_conf [loggers] keys=root [handlers] keys=consoleHandler [formatters] keys=simpleFormatter [logger_root] level=INFO handlers=consoleHandler [handler_consoleHandler] class=StreamHandler formatter=simpleFormatter args=(sys.stdout,) [formatter_simpleFormatter] format=%(name)s - %(levelname)s - %(message)s EOF heat-manage --log-config=$log_conf db_sync rm $log_conf # Do a final sanity check on the database. echo "SELECT * FROM migrate_version;" | mysql -u heat --password=${MYSQL_HEAT_PW} heat > /dev/null if ! [ $? -eq 0 ] then echo "Final sanity check failed." exit 1 fi echo "Complete!" heat-2014.1.5/bin/heat-manage0000775000567000056700000000217312540642614016701 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # 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. import os import sys # If ../heat/__init__.py exists, add ../ to Python search path, so that # it will override what happens to be installed in /usr/(local/)lib/python... POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)) if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')): sys.path.insert(0, POSSIBLE_TOPDIR) from heat.openstack.common import gettextutils gettextutils.install('heat') from heat.cmd import manage manage.main() heat-2014.1.5/bin/heat-engine0000775000567000056700000000430012540642614016710 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # # 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 Engine Server. This does the work of actually implementing the API calls made by the user. Normal communications is done via the heat API which then calls into this engine. """ import eventlet eventlet.monkey_patch() import os import sys # If ../heat/__init__.py exists, add ../ to Python search path, so that # it will override what happens to be installed in /usr/(local/)lib/python... POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)) if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')): sys.path.insert(0, POSSIBLE_TOPDIR) from heat.openstack.common import gettextutils gettextutils.install('heat', lazy=False) from oslo.config import cfg from heat.common import notify from heat.openstack.common import log as logging from heat.openstack.common import service from heat.rpc import api as rpc_api LOG = logging.getLogger('heat.engine') if __name__ == '__main__': cfg.CONF(project='heat', prog='heat-engine') cfg.CONF.default_log_levels = ['amqplib=WARN', 'sqlalchemy=WARN', 'qpid.messaging=INFO', 'keystone=INFO', 'eventlet.wsgi.server=WARN', ] logging.setup('heat') from heat.engine import service as engine srv = engine.EngineService(cfg.CONF.host, rpc_api.ENGINE_TOPIC) launcher = service.launch(srv) notify.startup_notify(cfg.CONF.onready) launcher.wait() heat-2014.1.5/bin/heat-api-cfn0000775000567000056700000000461012540642614016764 0ustar jenkinsjenkins00000000000000#!/usr/bin/env python # # 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 API Server. This implements an approximation of the Amazon CloudFormation API and translates it into a native representation. It then calls the heat-engine via AMQP RPC to implement them. """ import eventlet eventlet.monkey_patch(os=False) import os import sys # If ../heat/__init__.py exists, add ../ to Python search path, so that # it will override what happens to be installed in /usr/(local/)lib/python... possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)) if os.path.exists(os.path.join(possible_topdir, 'heat', '__init__.py')): sys.path.insert(0, possible_topdir) from heat.openstack.common import gettextutils gettextutils.install('heat', lazy=False) from oslo.config import cfg from heat.common import config from heat.common import wsgi from heat.common import notify from heat.openstack.common import log as logging LOG = logging.getLogger('heat.api.cfn') if __name__ == '__main__': try: cfg.CONF(project='heat', prog='heat-api-cfn') cfg.CONF.default_log_levels = ['amqplib=WARN', 'qpid.messaging=INFO', 'keystone=INFO', 'eventlet.wsgi.server=WARN', ] logging.setup('heat') app = config.load_paste_app() port = cfg.CONF.heat_api_cfn.bind_port host = cfg.CONF.heat_api_cfn.bind_host LOG.info('Starting Heat API on %s:%s' % (host, port)) server = wsgi.Server() server.start(app, cfg.CONF.heat_api_cfn, default_port=port) notify.startup_notify(cfg.CONF.onready) server.wait() except RuntimeError as e: sys.exit("ERROR: %s" % e) heat-2014.1.5/CONTRIBUTING.rst0000664000567000056700000000103212540642614016466 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.5/requirements.txt0000664000567000056700000000137712540642614017325 0ustar jenkinsjenkins00000000000000pbr>=0.6,<1.0 pycrypto>=2.6,<=2.6.1 eventlet>=0.13.0,<0.16.0 greenlet>=0.3.2,<=0.4.5 httplib2>=0.7.5,<=0.9 iso8601>=0.1.9,<=0.1.10 kombu>=2.5.0,<=3.0.7 argparse lxml>=2.3,<=3.4.2 netaddr>=0.7.6,<=0.7.14 six>=1.6.0,<=1.9.0 sqlalchemy-migrate>=0.8.2,!=0.8.4,<=0.9.1 python-novaclient>=2.17.0,<2.21 PasteDeploy>=1.5.0,<=1.5.2 requests>=1.1,<=2.6.0 Routes>=1.12.3,!=2.0 SQLAlchemy>=0.7.8,!=0.9.5,<=0.9.99 WebOb>=1.2.3,<=1.4 python-heatclient>=0.2.3,<=0.2.12 python-keystoneclient>=0.7.0,<0.12.0 python-swiftclient>=1.6,<=2.3.1 python-neutronclient>=2.3.4,<2.3.11 python-ceilometerclient>=1.0.6,<=1.0.12 python-cinderclient>=1.0.6,<=1.1.1 python-troveclient>=1.0.3,<=1.0.8 PyYAML>=3.1.0,<=3.11 paramiko>=1.9.0,<=1.15.2 Babel>=1.3,<=1.3 oslo.config>=1.2.0,<1.5 qpid-python heat-2014.1.5/PKG-INFO0000664000567000056700000000432212540643116015125 0ustar jenkinsjenkins00000000000000Metadata-Version: 1.1 Name: heat Version: 2014.1.5 Summary: OpenStack Orchestration Home-page: http://www.openstack.org/ Author: OpenStack Author-email: openstack-dev@lists.openstack.org License: UNKNOWN Description: ==== HEAT ==== Heat is a service to orchestrate multiple composite cloud applications using templates, through both an OpenStack-native ReST API and a CloudFormation-compatible Query API. Why heat? It makes the clouds rise and keeps them there. Getting Started --------------- If you'd like to run from the master branch, you can clone the git repo: git clone git@github.com:openstack/heat.git * Wiki: http://wiki.openstack.org/Heat * Developer docs: http://docs.openstack.org/developer/heat Python client ------------- https://github.com/openstack/python-heatclient References ---------- * http://docs.amazonwebservices.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html * http://docs.amazonwebservices.com/AWSCloudFormation/latest/UserGuide/create-stack.html * http://docs.amazonwebservices.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html * http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=tosca We have integration with ------------------------ * https://github.com/openstack/python-novaclient (instance) * https://github.com/openstack/python-keystoneclient (auth) * https://github.com/openstack/python-swiftclient (s3) * https://github.com/openstack/python-neutronclient (networking) Platform: UNKNOWN Classifier: Environment :: OpenStack Classifier: Intended Audience :: Information Technology Classifier: Intended Audience :: System Administrators Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: POSIX :: Linux Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 2.6 heat-2014.1.5/README.rst0000664000567000056700000000234412540642614015523 0ustar jenkinsjenkins00000000000000==== HEAT ==== Heat is a service to orchestrate multiple composite cloud applications using templates, through both an OpenStack-native ReST API and a CloudFormation-compatible Query API. Why heat? It makes the clouds rise and keeps them there. Getting Started --------------- If you'd like to run from the master branch, you can clone the git repo: git clone git@github.com:openstack/heat.git * Wiki: http://wiki.openstack.org/Heat * Developer docs: http://docs.openstack.org/developer/heat Python client ------------- https://github.com/openstack/python-heatclient References ---------- * http://docs.amazonwebservices.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html * http://docs.amazonwebservices.com/AWSCloudFormation/latest/UserGuide/create-stack.html * http://docs.amazonwebservices.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html * http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=tosca We have integration with ------------------------ * https://github.com/openstack/python-novaclient (instance) * https://github.com/openstack/python-keystoneclient (auth) * https://github.com/openstack/python-swiftclient (s3) * https://github.com/openstack/python-neutronclient (networking) heat-2014.1.5/ChangeLog0000664000567000056700000044435112540643115015613 0ustar jenkinsjenkins00000000000000CHANGES ======= 2014.1.5 -------- * Fix cloud-init Python syntax for Python < 2.6 * Updated from global requirements * Updated from global requirements * Bump stable/icehouse next version to 2014.1.5 2014.1.4 -------- * Use empty list in list_join for validation * Updated from global requirements * Updated from global requirements * Patch 033 migration to work w/ MySQL 5.6 * Call server volume detach only once * Use environment file in template-validate * Updated from global requirements * Catch NotFound error during loadbalancer deleting * Bump stable/icehouse next version to 2014.1.4 2014.1.3 -------- * Prevent excessive validation for maxPersonality limit * Updated from global requirements * Only delete stack user project from correct domain * Handle NotFoundException when deleting alarm * Support multiple heatclient versions for SD * Bump stable/icehouse next version to 2014.1.3 2014.1.2 -------- * Set python hash seed to 0 in tox.ini * Updated from global requirements * Stop periodic watcher tasks before deleting stack * Sync threadgroup module from the oslo stable branch * Move novaclient exceptions to heat.tests.v1_1.fakes * Pass the parent's registry into child stacks * Bump stable/icehouse next version to 2014.1.2 * Fix String Parameter Receive a unicode * Allow metadata updates to provider resources * Do no re-validate parameters for existing stacks * Do not validate constraints in schema constructor * Ensure routing key is specified in the address for a direct producer 2014.1.1 -------- * Avoid redundant polling of DB for metadata * Fix failed to delete the NovaFloatingIPAssociation resource * Fix status reason in events for deployment signals * Truncate status_reason to column length * Catch NotFound for keystone delete operations * Using correct attribute of exception * Allow NotFound to be created without args * Updated from global requirements * Don't dynamically create provider types in the global env * Ignore nova limits set to '-1' * Don't pass enable_snat by default in Router * Opening stable/icehouse 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.5/LICENSE0000664000567000056700000002363712540642611015046 0ustar jenkinsjenkins00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. heat-2014.1.5/openstack-common.conf0000664000567000056700000000111112540642614020147 0ustar jenkinsjenkins00000000000000[DEFAULT] # The list of modules to copy from openstack-common module=db module=db.sqlalchemy module=eventlet_backdoor module=excutils module=fixture module=gettextutils module=importutils module=install_venv_common module=jsonutils module=local module=log module=log_handler module=loopingcall module=network_utils module=notifier module=policy module=rpc module=service module=threadgroup module=timeutils module=uuidutils module=config module=strutils module=py3kcompat module=versionutils module=test module=crypto # The base module to hold the copy of openstack.common base=heat heat-2014.1.5/MANIFEST.in0000664000567000056700000000143312540642614015570 0ustar jenkinsjenkins00000000000000include AUTHORS include ChangeLog include CONTRIBUTING.rst include HACKING.rst include LICENSE include README.rst include MANIFEST.in pylintrc include openstack-common.conf include babel.cfg install.sh run_tests.sh tox.ini uninstall.sh include heat/cloudinit/config include heat/cloudinit/boothook.sh include heat/cloudinit/loguserdata.py include heat/cloudinit/part-handler.py include heat/db/sqlalchemy/migrate_repo/migrate.cfg include heat/db/sqlalchemy/migrate_repo/README include heat/openstack/common/README include heat/testing/README.rst include heat/tests/examples/tags.txt include heat/tests/testing-overview.txt include heat/tests/v1_1/testfile.txt include heat/tests/policy/deny_stack_user.json include heat/tests/policy/notallowed.json graft contrib graft etc graft doc graft tools heat-2014.1.5/etc/0000775000567000056700000000000012540643116014602 5ustar jenkinsjenkins00000000000000heat-2014.1.5/etc/heat/0000775000567000056700000000000012540643116015523 5ustar jenkinsjenkins00000000000000heat-2014.1.5/etc/heat/api-paste.ini0000664000567000056700000000626612540642614020123 0ustar jenkinsjenkins00000000000000 # heat-api pipeline [pipeline:heat-api] pipeline = faultwrap ssl versionnegotiation authurl authtoken context apiv1app # heat-api pipeline for standalone heat # ie. uses alternative auth backend that authenticates users against keystone # using username and password instead of validating token (which requires # an admin/service token). # To enable, in heat.conf: # [paste_deploy] # flavor = standalone # [pipeline:heat-api-standalone] pipeline = faultwrap ssl versionnegotiation authurl authpassword context apiv1app # heat-api pipeline for custom cloud backends # i.e. in heat.conf: # [paste_deploy] # flavor = custombackend # [pipeline:heat-api-custombackend] pipeline = faultwrap versionnegotiation context custombackendauth apiv1app # heat-api-cfn pipeline [pipeline:heat-api-cfn] pipeline = cfnversionnegotiation ec2authtoken authtoken context apicfnv1app # heat-api-cfn pipeline for standalone heat # relies exclusively on authenticating with ec2 signed requests [pipeline:heat-api-cfn-standalone] pipeline = cfnversionnegotiation ec2authtoken context apicfnv1app # heat-api-cloudwatch pipeline [pipeline:heat-api-cloudwatch] pipeline = versionnegotiation ec2authtoken authtoken context apicwapp # heat-api-cloudwatch pipeline for standalone heat # relies exclusively on authenticating with ec2 signed requests [pipeline:heat-api-cloudwatch-standalone] pipeline = versionnegotiation ec2authtoken context apicwapp [app:apiv1app] paste.app_factory = heat.common.wsgi:app_factory heat.app_factory = heat.api.openstack.v1:API [app:apicfnv1app] paste.app_factory = heat.common.wsgi:app_factory heat.app_factory = heat.api.cfn.v1:API [app:apicwapp] paste.app_factory = heat.common.wsgi:app_factory heat.app_factory = heat.api.cloudwatch:API [filter:versionnegotiation] paste.filter_factory = heat.common.wsgi:filter_factory heat.filter_factory = heat.api.openstack:version_negotiation_filter [filter:faultwrap] paste.filter_factory = heat.common.wsgi:filter_factory heat.filter_factory = heat.api.openstack:faultwrap_filter [filter:cfnversionnegotiation] paste.filter_factory = heat.common.wsgi:filter_factory heat.filter_factory = heat.api.cfn:version_negotiation_filter [filter:cwversionnegotiation] paste.filter_factory = heat.common.wsgi:filter_factory heat.filter_factory = heat.api.cloudwatch:version_negotiation_filter [filter:context] paste.filter_factory = heat.common.context:ContextMiddleware_filter_factory [filter:ec2authtoken] paste.filter_factory = heat.api.aws.ec2token:EC2Token_filter_factory [filter:ssl] paste.filter_factory = heat.common.wsgi:filter_factory heat.filter_factory = heat.api.openstack:sslmiddleware_filter # Middleware to set auth_url header appropriately [filter:authurl] paste.filter_factory = heat.common.auth_url:filter_factory # Auth middleware that validates token against keystone [filter:authtoken] paste.filter_factory = keystoneclient.middleware.auth_token:filter_factory # Auth middleware that validates username/password against keystone [filter:authpassword] paste.filter_factory = heat.common.auth_password:filter_factory # Auth middleware that validates against custom backend [filter:custombackendauth] paste.filter_factory = heat.common.custom_backend_auth:filter_factory heat-2014.1.5/etc/heat/templates/0000775000567000056700000000000012540643116017521 5ustar jenkinsjenkins00000000000000heat-2014.1.5/etc/heat/templates/AWS_RDS_DBInstance.yaml0000664000567000056700000000730612540642611023606 0ustar jenkinsjenkins00000000000000HeatTemplateFormatVersion: '2012-12-12' Description: 'Builtin AWS::RDS::DBInstance' Parameters: AllocatedStorage: Type: String DBInstanceClass: Type: String DBName: Type: String DBSecurityGroups: Type: CommaDelimitedList Default: '' Engine: Type: String AllowedValues: ['MySQL'] MasterUsername: Type: String MasterUserPassword: Type: String Port: Type: String Default: '3306' KeyName: Type: String Default: '' Mappings: DBInstanceToInstance: db.m1.small: {Instance: m1.small} db.m1.large: {Instance: m1.large} db.m1.xlarge: {Instance: m1.xlarge} db.m2.xlarge: {Instance: m2.xlarge} db.m2.2xlarge: {Instance: m2.2xlarge} db.m2.4xlarge: {Instance: m2.4xlarge} Resources: ServerSecurityGroup: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: 'Enable SSH access' SecurityGroupIngress: - IpProtocol: icmp FromPort: '-1' ToPort: '-1' CidrIp: '0.0.0.0/0' - IpProtocol: tcp FromPort: '22' ToPort : '22' CidrIp : '0.0.0.0/0' - IpProtocol: tcp FromPort: {Ref: Port} ToPort : {Ref: Port} CidrIp : '0.0.0.0/0' DatabaseInstance: Type: AWS::EC2::Instance Metadata: AWS::CloudFormation::Init: config: files: /tmp/db_setup.sql: content: 'Fn::Replace': - DBName: {Ref: DBName} MasterUserPassword: {Ref: MasterUserPassword} MasterUsername: {Ref: MasterUsername} - | CREATE DATABASE DBName; GRANT ALL PRIVILEGES ON DBName.* TO "MasterUsername"@"%" IDENTIFIED BY "MasterUserPassword"; FLUSH PRIVILEGES; EXIT mode: '000644' owner: root group: root packages: yum: mariadb: [] mariadb-server: [] services: systemd: mysqld: enabled: true ensureRunning: true Properties: ImageId: F19-x86_64-cfntools InstanceType: {'Fn::FindInMap': [DBInstanceToInstance, {Ref: DBInstanceClass}, Instance]} KeyName: {Ref: KeyName} SecurityGroups: [{"Ref" : "ServerSecurityGroup"}] UserData: Fn::Base64: Fn::Replace: - 'AWS::StackName': {Ref: 'AWS::StackName'} 'AWS::Region': {Ref: 'AWS::Region'} MasterUserPassword: {Ref: MasterUserPassword} WaitHandle: {Ref: WaitHandle} - | #!/bin/bash -v # iptables -F # Helper function function error_exit { /opt/aws/bin/cfn-signal -e 1 -r \"$1\" 'WaitHandle' exit 1 } /opt/aws/bin/cfn-init -s AWS::StackName -r DatabaseInstance --region AWS::Region || error_exit 'Failed to run cfn-init' # Setup MySQL root password and create a user mysqladmin -u root password 'MasterUserPassword' mysql -u root --password='MasterUserPassword' < /tmp/db_setup.sql || error_exit 'Failed to setup mysql' # Database setup completed, signal success /opt/aws/bin/cfn-signal -e 0 -r "MySQL server setup complete" 'WaitHandle' WaitHandle: Type: AWS::CloudFormation::WaitConditionHandle WaitCondition: Type: AWS::CloudFormation::WaitCondition DependsOn: DatabaseInstance Properties: Handle: {Ref: WaitHandle} Timeout: "600" Outputs: Endpoint.Address: {'Fn::GetAtt': [DatabaseInstance, PublicIp]} Endpoint.Port: {Ref: Port} heat-2014.1.5/etc/heat/templates/AWS_CloudWatch_Alarm.yaml0000664000567000056700000000507512540642614024301 0ustar jenkinsjenkins00000000000000HeatTemplateFormatVersion: '2012-12-12' Description: AWS::CloudWatch::Alarm using Ceilometer. Parameters: AlarmDescription: Type: String Default: An alarm EvaluationPeriods: Type: String MetricName: Type: String Namespace: Type: String Default: system/linux Period: Type: String ComparisonOperator: Type: String AllowedValues: [GreaterThanOrEqualToThreshold, GreaterThanThreshold, LessThanThreshold, LessThanOrEqualToThreshold] Statistic: Type: String AllowedValues: [SampleCount, Average, Sum, Minimum, Maximum] Threshold: Type: String Units: Type: String AllowedValues: [Seconds, Microseconds, Milliseconds, Bytes, Kilobytes, Megabytes, Gigabytes, Terabytes, Bits, Kilobits, Megabits, Gigabits, Terabits, Percent, Count, Bytes/Second, Kilobytes/Second, Megabytes/Second, Gigabytes/Second, Terabytes/Second, Bits/Second, Kilobits/Second, Megabits/Second, Gigabits/Second, Terabits/Second, Count/Second, None] Default: None AlarmActions: Type: CommaDelimitedList Default: '' OKActions: Type: CommaDelimitedList Default: '' InsufficientDataActions: Type: CommaDelimitedList Default: '' Dimensions: Type: CommaDelimitedList Mappings: ComparisonOperatorMap: LessThanOrEqualToThreshold: {Ceilometer: le} LessThanThreshold: {Ceilometer: lt} GreaterThanThreshold: {Ceilometer: gt} GreaterThanOrEqualToThreshold: {Ceilometer: ge} StatisticMap: SampleCount: {Ceilometer: count} Average: {Ceilometer: avg} Sum: {Ceilometer: sum} Minimum: {Ceilometer: min} Maximum: {Ceilometer: max} Resources: __alarm__: Type: OS::Ceilometer::Alarm Properties: description: Ref: AlarmDescription meter_name: Ref: MetricName period: Ref: Period evaluation_periods: Ref: EvaluationPeriods repeat_actions: true threshold: Ref: Threshold alarm_actions: "Fn::Split": [",", {Ref: AlarmActions}] ok_actions: "Fn::Split": [",", {Ref: OKActions}] insufficient_data_actions: "Fn::Split": [",", {Ref: InsufficientDataActions}] statistic: "Fn::FindInMap": [StatisticMap, {Ref: Statistic}, Ceilometer] comparison_operator: "Fn::FindInMap": [ComparisonOperatorMap, {Ref: ComparisonOperator}, Ceilometer] matching_metadata: "Fn::MemberListToMap": [Name, Value, {"Fn::Split": [",", {Ref: Dimensions}]}] heat-2014.1.5/etc/heat/policy.json0000664000567000056700000000570712540642614017730 0ustar jenkinsjenkins00000000000000{ "context_is_admin": "role:admin", "deny_stack_user": "not role:heat_stack_user", "deny_everybody": "!", "cloudformation:ListStacks": "rule:deny_stack_user", "cloudformation:CreateStack": "rule:deny_stack_user", "cloudformation:DescribeStacks": "rule:deny_stack_user", "cloudformation:DeleteStack": "rule:deny_stack_user", "cloudformation:UpdateStack": "rule:deny_stack_user", "cloudformation:DescribeStackEvents": "rule:deny_stack_user", "cloudformation:ValidateTemplate": "rule:deny_stack_user", "cloudformation:GetTemplate": "rule:deny_stack_user", "cloudformation:EstimateTemplateCost": "rule:deny_stack_user", "cloudformation:DescribeStackResource": "", "cloudformation:DescribeStackResources": "rule:deny_stack_user", "cloudformation:ListStackResources": "rule:deny_stack_user", "cloudwatch:DeleteAlarms": "rule:deny_stack_user", "cloudwatch:DescribeAlarmHistory": "rule:deny_stack_user", "cloudwatch:DescribeAlarms": "rule:deny_stack_user", "cloudwatch:DescribeAlarmsForMetric": "rule:deny_stack_user", "cloudwatch:DisableAlarmActions": "rule:deny_stack_user", "cloudwatch:EnableAlarmActions": "rule:deny_stack_user", "cloudwatch:GetMetricStatistics": "rule:deny_stack_user", "cloudwatch:ListMetrics": "rule:deny_stack_user", "cloudwatch:PutMetricAlarm": "rule:deny_stack_user", "cloudwatch:PutMetricData": "", "cloudwatch:SetAlarmState": "rule:deny_stack_user", "actions:action": "rule:deny_stack_user", "build_info:build_info": "rule:deny_stack_user", "events:index": "rule:deny_stack_user", "events:show": "rule:deny_stack_user", "resource:index": "rule:deny_stack_user", "resource:metadata": "", "resource:signal": "", "resource:show": "rule:deny_stack_user", "stacks:abandon": "rule:deny_stack_user", "stacks:create": "rule:deny_stack_user", "stacks:delete": "rule:deny_stack_user", "stacks:detail": "rule:deny_stack_user", "stacks:generate_template": "rule:deny_stack_user", "stacks:global_index": "rule:deny_everybody", "stacks:index": "rule:deny_stack_user", "stacks:list_resource_types": "rule:deny_stack_user", "stacks:lookup": "", "stacks:preview": "rule:deny_stack_user", "stacks:resource_schema": "rule:deny_stack_user", "stacks:show": "rule:deny_stack_user", "stacks:template": "rule:deny_stack_user", "stacks:update": "rule:deny_stack_user", "stacks:validate_template": "rule:deny_stack_user", "software_configs:create": "rule:deny_stack_user", "software_configs:show": "rule:deny_stack_user", "software_configs:delete": "rule:deny_stack_user", "software_deployments:index": "rule:deny_stack_user", "software_deployments:create": "rule:deny_stack_user", "software_deployments:show": "rule:deny_stack_user", "software_deployments:update": "rule:deny_stack_user", "software_deployments:delete": "rule:deny_stack_user", "software_deployments:metadata": "" } heat-2014.1.5/etc/heat/environment.d/0000775000567000056700000000000012540643116020311 5ustar jenkinsjenkins00000000000000heat-2014.1.5/etc/heat/environment.d/default.yaml0000664000567000056700000000066412540642614022631 0ustar jenkinsjenkins00000000000000 resource_registry: # allow older templates with Quantum in them. "OS::Quantum*": "OS::Neutron*" # Choose your implementation of AWS::CloudWatch::Alarm #"AWS::CloudWatch::Alarm": "file:///etc/heat/templates/AWS_CloudWatch_Alarm.yaml" "AWS::CloudWatch::Alarm": "OS::Heat::CWLiteAlarm" "OS::Metering::Alarm": "OS::Ceilometer::Alarm" "AWS::RDS::DBInstance": "file:///etc/heat/templates/AWS_RDS_DBInstance.yaml" heat-2014.1.5/etc/heat/heat.conf.sample0000664000567000056700000007430112540642614020602 0ustar jenkinsjenkins00000000000000[DEFAULT] # # Options defined in heat.api.middleware.ssl # # The HTTP Header that will be used to determine which the # original request protocol scheme was, even if it was removed # by an SSL terminator proxy. (string value) #secure_proxy_ssl_header=X-Forwarded-Proto # # Options defined in heat.common.config # # The default user for new instances. This option is # deprecated and will be removed in the Juno release. If it's # empty, Heat will use the default user set up with your cloud # image (for OS::Nova::Server) or 'ec2-user' (for # AWS::EC2::Instance). (string value) #instance_user=ec2-user # Driver to use for controlling instances. (string value) #instance_driver=heat.engine.nova # List of directories to search for plug-ins. (list value) #plugin_dirs=/usr/lib64/heat,/usr/lib/heat # The directory to search for environment files. (string # value) #environment_dir=/etc/heat/environment.d # Select deferred auth method, stored password or trusts. # (string value) #deferred_auth_method=password # Subset of trustor roles to be delegated to heat. (list # value) #trusts_delegated_roles=heat_stack_owner # Maximum resources allowed per top-level stack. (integer # value) #max_resources_per_stack=1000 # Maximum number of stacks any one tenant may have active at # one time. (integer value) #max_stacks_per_tenant=100 # Controls how many events will be pruned whenever a stack's # events exceed max_events_per_stack. Set this lower to keep # more events at the expense of more frequent purges. (integer # value) #event_purge_batch_size=10 # Maximum events that will be available per stack. Older # events will be deleted when this is reached. Set to 0 for # unlimited events per stack. (integer value) #max_events_per_stack=1000 # Timeout in seconds for stack action (ie. create or update). # (integer value) #stack_action_timeout=3600 # RPC timeout for the engine liveness check that is used for # stack locking. (integer value) #engine_life_check_timeout=2 # onready allows you to send a notification when the heat # processes are ready to serve. This is either a module with # the notify() method or a shell command. To enable # notifications with systemd, one may use the 'systemd-notify # --ready' shell command or the 'heat.common.systemd' # notification module. (string value) #onready= # Name of the engine node. This can be an opaque identifier. # It is not necessarily a hostname, FQDN, or IP address. # (string value) #host=heat # Seconds between running periodic tasks. (integer value) #periodic_interval=60 # URL of the Heat metadata server. (string value) #heat_metadata_server_url= # URL of the Heat waitcondition server. (string value) #heat_waitcondition_server_url= # URL of the Heat CloudWatch server. (string value) #heat_watch_server_url= # Instance connection to CFN/CW API via https. (string value) #instance_connection_is_secure=0 # Instance connection to CFN/CW API validate certs if SSL is # used. (string value) #instance_connection_https_validate_certificates=1 # Default region name used to get services endpoints. (string # value) #region_name_for_services= # Keystone role for heat template-defined users. (string # value) #heat_stack_user_role=heat_stack_user # Keystone domain ID which contains heat template-defined # users. (string value) #stack_user_domain= # Keystone username, a user with roles sufficient to manage # users and projects in the stack_user_domain. (string value) #stack_domain_admin= # Keystone password for stack_domain_admin user. (string # value) #stack_domain_admin_password= # Maximum raw byte size of any template. (integer value) #max_template_size=524288 # Maximum depth allowed when using nested stacks. (integer # value) #max_nested_stack_depth=3 # # Options defined in heat.common.crypt # # Encryption key used for authentication info in database. # (string value) #auth_encryption_key=notgood but just long enough i think # # Options defined in heat.common.heat_keystoneclient # # Fully qualified class name to use as a keystone backend. # (string value) #keystone_backend=heat.common.heat_keystoneclient.KeystoneClientV3 # # Options defined in heat.common.wsgi # # Maximum raw byte size of JSON request body. Should be larger # than max_template_size. (integer value) #max_json_body_size=1048576 # # Options defined in heat.db.api # # The backend to use for db. (string value) #db_backend=sqlalchemy # # Options defined in heat.engine.clients # # Fully qualified class name to use as a client backend. # (string value) #cloud_backend=heat.engine.clients.OpenStackClients # # Options defined in heat.engine.resources.loadbalancer # # Custom template for the built-in loadbalancer nested stack. # (string value) #loadbalancer_template= # # Options defined in heat.openstack.common.db.sqlalchemy.session # # the filename to use with sqlite (string value) #sqlite_db=heat.sqlite # If true, use synchronous mode for sqlite (boolean value) #sqlite_synchronous=true # # Options defined in heat.openstack.common.eventlet_backdoor # # Enable eventlet backdoor. Acceptable values are 0, , # and :, where 0 results in listening on a random # tcp port number; results in listening on the # specified port number (and not enabling backdoor if that # port is in use); and : results in listening on # the smallest unused port number within the specified range # of port numbers. The chosen port is displayed in the # service's log file. (string value) #backdoor_port= # # Options defined in heat.openstack.common.lockutils # # Whether to disable inter-process locks (boolean value) #disable_process_locking=false # Directory to use for lock files. (string value) #lock_path= # # Options defined in heat.openstack.common.log # # Print debugging output (set logging level to DEBUG instead # of default WARNING level). (boolean value) #debug=false # Print more verbose output (set logging level to INFO instead # of default WARNING level). (boolean value) #verbose=false # Log output to standard error (boolean value) #use_stderr=true # format string to use for log messages with context (string # value) #logging_context_format_string=%(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [%(request_id)s %(user_identity)s] %(instance)s%(message)s # format string to use for log messages without context # (string value) #logging_default_format_string=%(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [-] %(instance)s%(message)s # data to append to log format when level is DEBUG (string # value) #logging_debug_format_suffix=%(funcName)s %(pathname)s:%(lineno)d # prefix each line of exception output with this format # (string value) #logging_exception_prefix=%(asctime)s.%(msecs)03d %(process)d TRACE %(name)s %(instance)s # list of logger=LEVEL pairs (list value) #default_log_levels=amqp=WARN,amqplib=WARN,boto=WARN,qpid=WARN,sqlalchemy=WARN,suds=INFO,iso8601=WARN # publish error events (boolean value) #publish_errors=false # make deprecations fatal (boolean value) #fatal_deprecations=false # If an instance is passed with the log message, format it # like this (string value) #instance_format="[instance: %(uuid)s] " # If an instance UUID is passed with the log message, format # it like this (string value) #instance_uuid_format="[instance: %(uuid)s] " # The name of logging configuration file. It does not disable # existing loggers, but just appends specified logging # configuration to any other existing logging options. Please # see the Python logging module documentation for details on # logging configuration files. (string value) # Deprecated group/name - [DEFAULT]/log_config #log_config_append= # DEPRECATED. A logging.Formatter log message format string # which may use any of the available logging.LogRecord # attributes. This option is deprecated. Please use # logging_context_format_string and # logging_default_format_string instead. (string value) #log_format= # Format string for %%(asctime)s in log records. Default: # %(default)s (string value) #log_date_format=%Y-%m-%d %H:%M:%S # (Optional) Name of log file to output to. If no default is # set, logging will go to stdout. (string value) # Deprecated group/name - [DEFAULT]/logfile #log_file= # (Optional) The base directory used for relative --log-file # paths (string value) # Deprecated group/name - [DEFAULT]/logdir #log_dir= # Use syslog for logging. (boolean value) #use_syslog=false # syslog facility to receive log lines (string value) #syslog_log_facility=LOG_USER # # Options defined in heat.openstack.common.notifier.api # # Driver or drivers to handle sending notifications (multi # valued) #notification_driver= # Default notification level for outgoing notifications # (string value) #default_notification_level=INFO # Default publisher_id for outgoing notifications (string # value) #default_publisher_id= # # Options defined in heat.openstack.common.notifier.list_notifier # # List of drivers to send notifications (multi valued) #list_notifier_drivers=heat.openstack.common.notifier.no_op_notifier # # Options defined in heat.openstack.common.notifier.rpc_notifier # # AMQP topic used for OpenStack notifications (list value) #notification_topics=notifications # # Options defined in heat.openstack.common.policy # # JSON file containing policy (string value) #policy_file=policy.json # Rule enforced when requested rule is not found (string # value) #policy_default_rule=default # # Options defined in heat.openstack.common.rpc # # The messaging module to use, defaults to kombu. (string # value) #rpc_backend=heat.openstack.common.rpc.impl_kombu # Size of RPC thread pool (integer value) #rpc_thread_pool_size=64 # Size of RPC connection pool (integer value) #rpc_conn_pool_size=30 # Seconds to wait for a response from call or multicall # (integer value) #rpc_response_timeout=60 # Seconds to wait before a cast expires (TTL). Only supported # by impl_zmq. (integer value) #rpc_cast_timeout=30 # Modules of exceptions that are permitted to be recreated # upon receiving exception data from an rpc call. (list value) #allowed_rpc_exception_modules=nova.exception,cinder.exception,exceptions # If passed, use a fake RabbitMQ provider (boolean value) #fake_rabbit=false # AMQP exchange to connect to if using RabbitMQ or Qpid # (string value) #control_exchange=heat # # Options defined in heat.openstack.common.rpc.amqp # # Use durable queues in amqp. (boolean value) # Deprecated group/name - [DEFAULT]/rabbit_durable_queues #amqp_durable_queues=false # Auto-delete queues in amqp. (boolean value) #amqp_auto_delete=false # # Options defined in heat.openstack.common.rpc.impl_kombu # # SSL version to use (valid only if SSL enabled). valid values # are TLSv1, SSLv23 and SSLv3. SSLv2 may be available on some # distributions (string value) #kombu_ssl_version= # SSL key file (valid only if SSL enabled) (string value) #kombu_ssl_keyfile= # SSL cert file (valid only if SSL enabled) (string value) #kombu_ssl_certfile= # SSL certification authority file (valid only if SSL enabled) # (string value) #kombu_ssl_ca_certs= # The RabbitMQ broker address where a single node is used # (string value) #rabbit_host=localhost # The RabbitMQ broker port where a single node is used # (integer value) #rabbit_port=5672 # RabbitMQ HA cluster host:port pairs (list value) #rabbit_hosts=$rabbit_host:$rabbit_port # connect over SSL for RabbitMQ (boolean value) #rabbit_use_ssl=false # the RabbitMQ userid (string value) #rabbit_userid=guest # the RabbitMQ password (string value) #rabbit_password=guest # the RabbitMQ virtual host (string value) #rabbit_virtual_host=/ # how frequently to retry connecting with RabbitMQ (integer # value) #rabbit_retry_interval=1 # how long to backoff for between retries when connecting to # RabbitMQ (integer value) #rabbit_retry_backoff=2 # maximum retries with trying to connect to RabbitMQ (the # default of 0 implies an infinite retry count) (integer # value) #rabbit_max_retries=0 # use H/A queues in RabbitMQ (x-ha-policy: all).You need to # wipe RabbitMQ database when changing this option. (boolean # value) #rabbit_ha_queues=false # # Options defined in heat.openstack.common.rpc.impl_qpid # # Qpid broker hostname (string value) #qpid_hostname=localhost # Qpid broker port (integer value) #qpid_port=5672 # Qpid HA cluster host:port pairs (list value) #qpid_hosts=$qpid_hostname:$qpid_port # Username for qpid connection (string value) #qpid_username= # Password for qpid connection (string value) #qpid_password= # Space separated list of SASL mechanisms to use for auth # (string value) #qpid_sasl_mechanisms= # Seconds between connection keepalive heartbeats (integer # value) #qpid_heartbeat=60 # Transport to use, either 'tcp' or 'ssl' (string value) #qpid_protocol=tcp # Disable Nagle algorithm (boolean value) #qpid_tcp_nodelay=true # The qpid topology version to use. Version 1 is what was # originally used by impl_qpid. Version 2 includes some # backwards-incompatible changes that allow broker federation # to work. Users should update to version 2 when they are # able to take everything down, as it requires a clean break. # (integer value) #qpid_topology_version=1 # # Options defined in heat.openstack.common.rpc.impl_zmq # # ZeroMQ bind address. Should be a wildcard (*), an ethernet # interface, or IP. The "host" option should point or resolve # to this address. (string value) #rpc_zmq_bind_address=* # MatchMaker driver (string value) #rpc_zmq_matchmaker=heat.openstack.common.rpc.matchmaker.MatchMakerLocalhost # ZeroMQ receiver listening port (integer value) #rpc_zmq_port=9501 # Number of ZeroMQ contexts, defaults to 1 (integer value) #rpc_zmq_contexts=1 # Maximum number of ingress messages to locally buffer per # topic. Default is unlimited. (integer value) #rpc_zmq_topic_backlog= # Directory for holding IPC sockets (string value) #rpc_zmq_ipc_dir=/var/run/openstack # Name of this node. Must be a valid hostname, FQDN, or IP # address. Must match "host" option, if running Nova. (string # value) #rpc_zmq_host=heat # # Options defined in heat.openstack.common.rpc.matchmaker # # Heartbeat frequency (integer value) #matchmaker_heartbeat_freq=300 # Heartbeat time-to-live. (integer value) #matchmaker_heartbeat_ttl=600 [auth_password] # # Options defined in heat.common.config # # Allow orchestration of multiple clouds. (boolean value) #multi_cloud=false # Allowed keystone endpoints for auth_uri when multi_cloud is # enabled. At least one endpoint needs to be specified. (list # value) #allowed_auth_uris= [clients] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_ceilometer] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_cinder] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_heat] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false # Optional heat url in format like # http://0.0.0.0:8004/v1/%(tenant_id)s. (string value) #url= [clients_keystone] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_neutron] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_nova] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_swift] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [clients_trove] # # Options defined in heat.common.config # # Type of endpoint in Identity service catalog to use for # communication with the OpenStack service. (string value) #endpoint_type=publicURL # Optional CA cert file to use in SSL connections. (string # value) #ca_file= # Optional PEM-formatted certificate chain file. (string # value) #cert_file= # Optional PEM-formatted file that contains the private key. # (string value) #key_file= # If set, then the server's certificate will not be verified. # (boolean value) #insecure=false [database] # # Options defined in heat.openstack.common.db.api # # The backend to use for db (string value) # Deprecated group/name - [DEFAULT]/db_backend #backend=sqlalchemy # # Options defined in heat.openstack.common.db.sqlalchemy.session # # The SQLAlchemy connection string used to connect to the # database (string value) # Deprecated group/name - [DEFAULT]/sql_connection # Deprecated group/name - [DATABASE]/sql_connection # Deprecated group/name - [sql]/connection #connection=sqlite:////heat/openstack/common/db/$sqlite_db # The SQLAlchemy connection string used to connect to the # slave database (string value) #slave_connection= # timeout before idle sql connections are reaped (integer # value) # Deprecated group/name - [DEFAULT]/sql_idle_timeout # Deprecated group/name - [DATABASE]/sql_idle_timeout # Deprecated group/name - [sql]/idle_timeout #idle_timeout=3600 # Minimum number of SQL connections to keep open in a pool # (integer value) # Deprecated group/name - [DEFAULT]/sql_min_pool_size # Deprecated group/name - [DATABASE]/sql_min_pool_size #min_pool_size=1 # Maximum number of SQL connections to keep open in a pool # (integer value) # Deprecated group/name - [DEFAULT]/sql_max_pool_size # Deprecated group/name - [DATABASE]/sql_max_pool_size #max_pool_size= # maximum db connection retries during startup. (setting -1 # implies an infinite retry count) (integer value) # Deprecated group/name - [DEFAULT]/sql_max_retries # Deprecated group/name - [DATABASE]/sql_max_retries #max_retries=10 # interval between retries of opening a sql connection # (integer value) # Deprecated group/name - [DEFAULT]/sql_retry_interval # Deprecated group/name - [DATABASE]/reconnect_interval #retry_interval=10 # If set, use this value for max_overflow with sqlalchemy # (integer value) # Deprecated group/name - [DEFAULT]/sql_max_overflow # Deprecated group/name - [DATABASE]/sqlalchemy_max_overflow #max_overflow= # Verbosity of SQL debugging information. 0=None, # 100=Everything (integer value) # Deprecated group/name - [DEFAULT]/sql_connection_debug #connection_debug=0 # Add python stack traces to SQL as comment strings (boolean # value) # Deprecated group/name - [DEFAULT]/sql_connection_trace #connection_trace=false # If set, use this value for pool_timeout with sqlalchemy # (integer value) # Deprecated group/name - [DATABASE]/sqlalchemy_pool_timeout #pool_timeout= [ec2authtoken] # # Options defined in heat.api.aws.ec2token # # Authentication Endpoint URI. (string value) #auth_uri= # Allow orchestration of multiple clouds. (boolean value) #multi_cloud=false # Allowed keystone endpoints for auth_uri when multi_cloud is # enabled. At least one endpoint needs to be specified. (list # value) #allowed_auth_uris= [heat_api] # # Options defined in heat.common.wsgi # # Address to bind the server. Useful when selecting a # particular network interface. (string value) #bind_host=0.0.0.0 # The port on which the server will listen. (integer value) #bind_port=8004 # Number of backlog requests to configure the socket with. # (integer value) #backlog=4096 # Location of the SSL certificate file to use for SSL mode. # (string value) #cert_file= # Location of the SSL key file to use for enabling SSL mode. # (string value) #key_file= # Number of workers for Heat service. (integer value) #workers=0 # Maximum line size of message headers to be accepted. # max_header_line may need to be increased when using large # tokens (typically those generated by the Keystone v3 API # with big service catalogs). (integer value) #max_header_line=16384 [heat_api_cfn] # # Options defined in heat.common.wsgi # # Address to bind the server. Useful when selecting a # particular network interface. (string value) #bind_host=0.0.0.0 # The port on which the server will listen. (integer value) #bind_port=8000 # Number of backlog requests to configure the socket with. # (integer value) #backlog=4096 # Location of the SSL certificate file to use for SSL mode. # (string value) #cert_file= # Location of the SSL key file to use for enabling SSL mode. # (string value) #key_file= # Number of workers for Heat service. (integer value) #workers=0 # Maximum line size of message headers to be accepted. # max_header_line may need to be increased when using large # tokens (typically those generated by the Keystone v3 API # with big service catalogs). (integer value) #max_header_line=16384 [heat_api_cloudwatch] # # Options defined in heat.common.wsgi # # Address to bind the server. Useful when selecting a # particular network interface. (string value) #bind_host=0.0.0.0 # The port on which the server will listen. (integer value) #bind_port=8003 # Number of backlog requests to configure the socket with. # (integer value) #backlog=4096 # Location of the SSL certificate file to use for SSL mode. # (string value) #cert_file= # Location of the SSL key file to use for enabling SSL mode. # (string value) #key_file= # Number of workers for Heat service. (integer value) #workers=0 # Maximum line size of message headers to be accepted. # max_header_line may need to be increased when using large # tokens (typically those generated by the Keystone v3 API # with big service catalogs.) (integer value) #max_header_line=16384 [keystone_authtoken] # # Options defined in keystoneclient.middleware.auth_token # # Prefix to prepend at the beginning of the path (string # value) #auth_admin_prefix= # Host providing the admin Identity API endpoint (string # value) #auth_host=127.0.0.1 # Port of the admin Identity API endpoint (integer value) #auth_port=35357 # Protocol of the admin Identity API endpoint(http or https) # (string value) #auth_protocol=https # Complete public Identity API endpoint (string value) #auth_uri= # API version of the admin Identity API endpoint (string # value) #auth_version= # Do not handle authorization requests within the middleware, # but delegate the authorization decision to downstream WSGI # components (boolean value) #delay_auth_decision=false # Request timeout value for communicating with Identity API # server. (boolean value) #http_connect_timeout= # How many times are we trying to reconnect when communicating # with Identity API Server. (integer value) #http_request_max_retries=3 # Single shared secret with the Keystone configuration used # for bootstrapping a Keystone installation, or otherwise # bypassing the normal authentication process. (string value) #admin_token= # Keystone account username (string value) #admin_user= # Keystone account password (string value) #admin_password= # Keystone service account tenant name to validate user tokens # (string value) #admin_tenant_name=admin # Env key for the swift cache (string value) #cache= # Required if Keystone server requires client certificate # (string value) #certfile= # Required if Keystone server requires client certificate # (string value) #keyfile= # A PEM encoded Certificate Authority to use when verifying # HTTPs connections. Defaults to system CAs. (string value) #cafile= # Verify HTTPS connections. (boolean value) #insecure=false # Directory used to cache files related to PKI tokens (string # value) #signing_dir= # Optionally specify a list of memcached server(s) to use for # caching. If left undefined, tokens will instead be cached # in-process. (list value) # Deprecated group/name - [DEFAULT]/memcache_servers #memcached_servers= # In order to prevent excessive effort spent validating # tokens, the middleware caches previously-seen tokens for a # configurable duration (in seconds). Set to -1 to disable # caching completely. (integer value) #token_cache_time=300 # Determines the frequency at which the list of revoked tokens # is retrieved from the Identity service (in seconds). A high # number of revocation events combined with a low cache # duration may significantly reduce performance. (integer # value) #revocation_cache_time=300 # (optional) if defined, indicate whether token data should be # authenticated or authenticated and encrypted. Acceptable # values are MAC or ENCRYPT. If MAC, token data is # authenticated (with HMAC) in the cache. If ENCRYPT, token # data is encrypted and authenticated in the cache. If the # value is not one of these options or empty, auth_token will # raise an exception on initialization. (string value) #memcache_security_strategy= # (optional, mandatory if memcache_security_strategy is # defined) this string is used for key derivation. (string # value) #memcache_secret_key= # (optional) indicate whether to set the X-Service-Catalog # header. If False, middleware will not ask for service # catalog on token validation and will not set the X-Service- # Catalog header. (boolean value) #include_service_catalog=true # Used to control the use and type of token binding. Can be # set to: "disabled" to not check token binding. "permissive" # (default) to validate binding information if the bind type # is of a form known to the server and ignore it if not. # "strict" like "permissive" but if the bind type is unknown # the token will be rejected. "required" any form of token # binding is needed to be allowed. Finally the name of a # binding method that must be present in tokens. (string # value) #enforce_token_bind=permissive [matchmaker_redis] # # Options defined in heat.openstack.common.rpc.matchmaker_redis # # Host to locate redis (string value) #host=127.0.0.1 # Use this port to connect to redis host. (integer value) #port=6379 # Password for Redis server. (optional) (string value) #password= [matchmaker_ring] # # Options defined in heat.openstack.common.rpc.matchmaker_ring # # Matchmaker ring file (JSON) (string value) # Deprecated group/name - [DEFAULT]/matchmaker_ringfile #ringfile=/etc/oslo/matchmaker_ring.json [paste_deploy] # # Options defined in heat.common.config # # The flavor to use. (string value) #flavor= # The API paste config file to use. (string value) #api_paste_config=api-paste.ini [revision] # # Options defined in heat.common.config # # Heat build revision. If you would prefer to manage your # build revision separately, you can move this section to a # different file and add it as another config option. (string # value) #heat_revision=unknown [rpc_notifier2] # # Options defined in heat.openstack.common.notifier.rpc_notifier2 # # AMQP topic(s) used for OpenStack notifications (list value) #topics=notifications [ssl] # # Options defined in heat.openstack.common.sslutils # # CA certificate file to use to verify connecting clients # (string value) #ca_file= # Certificate file to use when starting the server securely # (string value) #cert_file= # Private key file to use when starting the server securely # (string value) #key_file= heat-2014.1.5/test-requirements.txt0000664000567000056700000000054612540642614020277 0ustar jenkinsjenkins00000000000000# Hacking already pins down pep8, pyflakes and flake8 hacking>=0.8.0,<0.9 coverage>=3.6,<=3.7.1 discover<=0.4.0 mock>=1.0,<=1.0.1 mox>=0.5.3,<=0.5.3 testtools>=0.9.34,!=1.2.0,!=1.4.0,<=1.7.1 testrepository>=0.0.18,<=0.0.20 testscenarios>=0.4,<=0.4 python-glanceclient>=0.9.0,!=0.14.0,<=0.14.2 sphinx>=1.1.2,<1.1.999 oslosphinx<=2.5.0 lockfile>=0.8,<=0.10.2 heat-2014.1.5/doc/0000775000567000056700000000000012540643116014574 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/Makefile0000664000567000056700000001267512540642614016251 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.5/doc/README.rst0000664000567000056700000000135512540642611016266 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.5/doc/source/0000775000567000056700000000000012540643116016074 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/conf.py0000664000567000056700000003672012540642614017405 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.5/doc/source/getting_started/0000775000567000056700000000000012540643116021263 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/getting_started/on_fedora.rst0000664000567000056700000000364012540642614023756 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.5/doc/source/getting_started/jeos_building.rst0000664000567000056700000001530112540642614024634 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.5/doc/source/getting_started/on_devstack.rst0000664000567000056700000001103212540642614024314 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.5/doc/source/getting_started/on_other.rst0000664000567000056700000000206612540642614023640 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.5/doc/source/getting_started/on_ubuntu.rst0000664000567000056700000000173412540642611024037 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.5/doc/source/getting_started/index.rst0000664000567000056700000000134712540642611023130 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.5/doc/source/getting_started/standalone.rst0000664000567000056700000000600012540642614024143 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.5/doc/source/ext/0000775000567000056700000000000012540643116016674 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/ext/resources.py0000664000567000056700000002505212540642614021266 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.5/doc/source/ext/__init__.py0000664000567000056700000000000012540642611020772 0ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/scale_deployment.rst0000664000567000056700000002647612540642614022176 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.5/doc/source/glossary.rst0000664000567000056700000001513112540642611020471 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.5/doc/source/templates/0000775000567000056700000000000012540643116020072 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/templates/cfn/0000775000567000056700000000000012540643116020640 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/templates/cfn/WordPress_Single_Instance.rst0000664000567000056700000000333012540642614026450 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.5/doc/source/templates/index.rst0000664000567000056700000000150012540642614021731 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.5/doc/source/templates/hot/0000775000567000056700000000000012540643116020664 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/templates/hot/hello_world.rst0000664000567000056700000000225412540642614023735 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.5/doc/source/architecture.rst0000664000567000056700000000701012540642614021310 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.5/doc/source/man/0000775000567000056700000000000012540643116016647 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/man/heat-api-cloudwatch.rst0000664000567000056700000000142212540642614023225 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.5/doc/source/man/heat-manage.rst0000664000567000056700000000211612540642614021552 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.5/doc/source/man/heat-keystone-setup.rst0000664000567000056700000000116112540642614023320 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.5/doc/source/man/heat-db-setup.rst0000664000567000056700000000311512540642614022045 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.5/doc/source/man/heat-engine.rst0000664000567000056700000000156512540642614021576 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.5/doc/source/man/heat-api-cfn.rst0000664000567000056700000000167612540642614021651 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.5/doc/source/man/index.rst0000664000567000056700000000057712540642614020523 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.5/doc/source/man/heat-api.rst0000664000567000056700000000162112540642614021073 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.5/doc/source/index.rst0000664000567000056700000000527112540642614017744 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.5/doc/source/sourcecode/0000775000567000056700000000000012540643116020227 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/sourcecode/.gitignore0000664000567000056700000000000612540642611022212 0ustar jenkinsjenkins00000000000000*.rst heat-2014.1.5/doc/source/template_guide/0000775000567000056700000000000012540643116021064 5ustar jenkinsjenkins00000000000000heat-2014.1.5/doc/source/template_guide/openstack.rst0000664000567000056700000000122112540642614023603 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.5/doc/source/template_guide/environment.rst0000664000567000056700000000507312540642614024171 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.5/doc/source/template_guide/functions.rst0000664000567000056700000001364112540642614023635 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.5/doc/source/template_guide/cfn.rst0000664000567000056700000000126012540642614022365 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. CloudFormation Compatible Resource Types ---------------------------------------- .. resourcepages:: AWS::heat-2014.1.5/doc/source/template_guide/hot_guide.rst0000664000567000056700000002056112540642614023573 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.5/doc/source/template_guide/index.rst0000664000567000056700000000132712540642614022732 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.5/doc/source/template_guide/contrib.rst0000664000567000056700000000317112540642614023262 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.5/doc/source/template_guide/hot_spec.rst0000664000567000056700000006062012540642614023430 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: